ragtime-cli 0.2.6__tar.gz → 0.2.8__tar.gz

{ragtime_cli-0.2.6/ragtime_cli.egg-info → ragtime_cli-0.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ragtime-cli
-Version: 0.2.6
+Version: 0.2.8
 Summary: Local-first memory and RAG system for Claude Code - semantic search over code, docs, and team knowledge
 Author-email: Bret Martineau <bretwardjames@gmail.com>
 License-Expression: MIT

{ragtime_cli-0.2.6 → ragtime_cli-0.2.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ragtime-cli"
-version = "0.2.6"
+version = "0.2.8"
 description = "Local-first memory and RAG system for Claude Code - semantic search over code, docs, and team knowledge"
 readme = "README.md"
 license = "MIT"

{ragtime_cli-0.2.6 → ragtime_cli-0.2.8/ragtime_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ragtime-cli
-Version: 0.2.6
+Version: 0.2.8
 Summary: Local-first memory and RAG system for Claude Code - semantic search over code, docs, and team knowledge
 Author-email: Bret Martineau <bretwardjames@gmail.com>
 License-Expression: MIT

{ragtime_cli-0.2.6 → ragtime_cli-0.2.8}/src/cli.py

@@ -75,6 +75,7 @@ def check_ghp_installed() -> bool:
 
 def get_issue_from_ghp(issue_num: int, path: Path) -> dict | None:
     """Get issue details using ghp issue open."""
+    import json
     try:
         result = subprocess.run(
             ["ghp", "issue", "open", str(issue_num), "--json"],
@@ -84,15 +85,15 @@ def get_issue_from_ghp(issue_num: int, path: Path) -> dict | None:
             timeout=30,
         )
         if result.returncode == 0:
-            import json
             return json.loads(result.stdout)
-    except (subprocess.TimeoutExpired, FileNotFoundError, Exception):
+    except (subprocess.TimeoutExpired, FileNotFoundError, json.JSONDecodeError):
         pass
     return None
 
 
 def get_issue_from_gh(issue_num: int, path: Path) -> dict | None:
     """Get issue details using gh CLI."""
+    import json
     try:
         result = subprocess.run(
             ["gh", "issue", "view", str(issue_num), "--json", "title,body,labels,number"],
@@ -102,9 +103,8 @@ def get_issue_from_gh(issue_num: int, path: Path) -> dict | None:
             timeout=30,
         )
         if result.returncode == 0:
-            import json
             return json.loads(result.stdout)
-    except (subprocess.TimeoutExpired, FileNotFoundError, Exception):
+    except (subprocess.TimeoutExpired, FileNotFoundError, json.JSONDecodeError):
         pass
     return None
 
@@ -169,7 +169,7 @@ def get_remote_branches_with_ragtime(path: Path) -> list[str]:
 
 
 @click.group()
-@click.version_option(version="0.2.6")
+@click.version_option(version="0.2.8")
 def main():
     """Ragtime - semantic search over code and documentation."""
     pass
@@ -258,12 +258,73 @@ Add your team's conventions above. Each rule should be:
         click.echo(f"  Install for enhanced workflow: npm install -g @bretwardjames/ghp-cli")
 
 
+# Batch size for ChromaDB upserts (embedding computation happens here)
+INDEX_BATCH_SIZE = 100
+
+
+def _upsert_entries(db, entries, entry_type: str = "docs", label: str = "  Embedding"):
+    """Upsert entries to ChromaDB in batches with progress bar."""
+    if not entries:
+        return
+
+    # Process in batches with progress feedback
+    batches = [entries[i:i + INDEX_BATCH_SIZE] for i in range(0, len(entries), INDEX_BATCH_SIZE)]
+
+    with click.progressbar(
+        batches,
+        label=label,
+        show_percent=True,
+        show_pos=True,
+        item_show_func=lambda b: f"{len(b)} items" if b else "",
+    ) as batch_iter:
+        for batch in batch_iter:
+            if entry_type == "code":
+                ids = [f"{e.file_path}:{e.line_number}:{e.symbol_name}" for e in batch]
+            else:
+                ids = [e.file_path for e in batch]
+
+            documents = [e.content for e in batch]
+            metadatas = [e.to_metadata() for e in batch]
+            db.upsert(ids=ids, documents=documents, metadatas=metadatas)
+
+
+def _get_files_to_process(
+    all_files: list[Path],
+    indexed_files: dict[str, float],
+) -> tuple[list[Path], list[str]]:
+    """
+    Compare files on disk with indexed files to determine what needs processing.
+
+    Returns:
+        (files_to_index, files_to_delete)
+    """
+    disk_files = {str(f): os.path.getmtime(f) for f in all_files}
+
+    to_index = []
+    for file_path in all_files:
+        path_str = str(file_path)
+        disk_mtime = disk_files[path_str]
+        indexed_mtime = indexed_files.get(path_str, 0.0)
+
+        # Index if new or modified (with 1-second tolerance for filesystem precision)
+        if disk_mtime > indexed_mtime + 1.0:
+            to_index.append(file_path)
+
+    # Find deleted files (in index but not on disk)
+    to_delete = [f for f in indexed_files.keys() if f not in disk_files]
+
+    return to_index, to_delete
+
+
 @main.command()
 @click.argument("path", type=click.Path(exists=True, path_type=Path), default=".")
 @click.option("--type", "index_type", type=click.Choice(["all", "docs", "code"]), default="all")
 @click.option("--clear", is_flag=True, help="Clear existing index before indexing")
 def index(path: Path, index_type: str, clear: bool):
-    """Index a project directory."""
+    """Index a project directory.
+
+    Without --clear, performs incremental indexing (only changed files).
+    """
     path = path.resolve()
     db = get_db(path)
     config = RagtimeConfig.load(path)
@@ -276,7 +337,10 @@ def index(path: Path, index_type: str, clear: bool):
             db.clear(type_filter=index_type)
 
     if index_type in ("all", "docs"):
-        # Discover all doc files first
+        # Get currently indexed docs
+        indexed_docs = {} if clear else db.get_indexed_files("docs")
+
+        # Discover all doc files
         all_doc_files = []
         for docs_path in config.docs.paths:
             docs_root = path / docs_path
@@ -290,39 +354,55 @@ def index(path: Path, index_type: str, clear: bool):
             )
             all_doc_files.extend(files)
 
-        if all_doc_files:
+        if all_doc_files or indexed_docs:
+            # Determine what needs processing
+            to_index, to_delete = _get_files_to_process(all_doc_files, indexed_docs)
+
             click.echo(f"Found {len(all_doc_files)} doc files")
-            total_entries = []
-            with click.progressbar(
-                all_doc_files,
-                label="  Processing",
-                show_percent=True,
-                show_pos=True,
-                item_show_func=lambda f: f.name[:30] if f else "",
-            ) as files:
-                for file_path in files:
-                    entry = index_doc_file(file_path)
-                    if entry:
-                        total_entries.append(entry)
-
-            if total_entries:
-                ids = [e.file_path for e in total_entries]
-                documents = [e.content for e in total_entries]
-                metadatas = [e.to_metadata() for e in total_entries]
-                db.upsert(ids=ids, documents=documents, metadatas=metadatas)
-                click.echo(f"  Indexed {len(total_entries)} documents")
-            else:
-                click.echo("  No valid documents found")
+            if not clear:
+                unchanged = len(all_doc_files) - len(to_index)
+                if unchanged > 0:
+                    click.echo(f"  {unchanged} unchanged, {len(to_index)} to index")
+                if to_delete:
+                    click.echo(f"  {len(to_delete)} to remove (deleted from disk)")
+
+            # Delete removed files
+            if to_delete:
+                db.delete_by_file(to_delete, "docs")
+
+            # Index new/changed files
+            if to_index:
+                entries = []
+                with click.progressbar(
+                    to_index,
+                    label="  Parsing",
+                    show_percent=True,
+                    show_pos=True,
+                    item_show_func=lambda f: f.name[:30] if f else "",
+                ) as files:
+                    for file_path in files:
+                        entry = index_doc_file(file_path)
+                        if entry:
+                            entries.append(entry)
+
+                if entries:
+                    _upsert_entries(db, entries, "docs")
+                    click.echo(f"  Indexed {len(entries)} documents")
+            elif not to_delete:
+                click.echo("  All docs up to date")
         else:
             click.echo("  No documents found")
 
     if index_type in ("all", "code"):
+        # Get currently indexed code files
+        indexed_code = {} if clear else db.get_indexed_files("code")
+
         # Build exclusion list for code
         code_exclude = list(config.code.exclude)
         for docs_path in config.docs.paths:
             code_exclude.append(f"**/{docs_path}/**")
 
-        # Discover all code files first
+        # Discover all code files
         all_code_files = []
         for code_path_str in config.code.paths:
             code_root = path / code_path_str
@@ -336,36 +416,47 @@ def index(path: Path, index_type: str, clear: bool):
             )
             all_code_files.extend(files)
 
-        if all_code_files:
+        if all_code_files or indexed_code:
+            # Determine what needs processing
+            to_index, to_delete = _get_files_to_process(all_code_files, indexed_code)
+
             click.echo(f"Found {len(all_code_files)} code files")
-            total_entries = []
-            with click.progressbar(
-                all_code_files,
-                label="  Processing",
-                show_percent=True,
-                show_pos=True,
-                item_show_func=lambda f: f.name[:30] if f else "",
-            ) as files:
-                for file_path in files:
-                    file_entries = index_code_file(file_path)
-                    total_entries.extend(file_entries)
-
-            if total_entries:
-                # Create unique IDs: file:line:symbol
-                ids = [f"{e.file_path}:{e.line_number}:{e.symbol_name}" for e in total_entries]
-                documents = [e.content for e in total_entries]
-                metadatas = [e.to_metadata() for e in total_entries]
-                db.upsert(ids=ids, documents=documents, metadatas=metadatas)
-                click.echo(f"  Indexed {len(total_entries)} code symbols")
-
-                # Show breakdown by type
+            if not clear:
+                unchanged = len(all_code_files) - len(to_index)
+                if unchanged > 0:
+                    click.echo(f"  {unchanged} unchanged, {len(to_index)} to index")
+                if to_delete:
+                    click.echo(f"  {len(to_delete)} to remove (deleted from disk)")
+
+            # Delete removed files
+            if to_delete:
+                db.delete_by_file(to_delete, "code")
+
+            # Index new/changed files
+            if to_index:
+                entries = []
                 by_type = {}
-                for e in total_entries:
-                    by_type[e.symbol_type] = by_type.get(e.symbol_type, 0) + 1
-                breakdown = ", ".join(f"{count} {typ}s" for typ, count in sorted(by_type.items()))
-                click.echo(f"    ({breakdown})")
-            else:
-                click.echo("  No code symbols found")
+                with click.progressbar(
+                    to_index,
+                    label="  Parsing",
+                    show_percent=True,
+                    show_pos=True,
+                    item_show_func=lambda f: f.name[:30] if f else "",
+                ) as files:
+                    for file_path in files:
+                        file_entries = index_code_file(file_path)
+                        for entry in file_entries:
+                            entries.append(entry)
+                            by_type[entry.symbol_type] = by_type.get(entry.symbol_type, 0) + 1
+
+                if entries:
+                    click.echo(f"  Found {len(entries)} symbols")
+                    _upsert_entries(db, entries, "code")
+                    click.echo(f"  Indexed {len(entries)} code symbols")
+                    breakdown = ", ".join(f"{count} {typ}s" for typ, count in sorted(by_type.items()))
+                    click.echo(f"    ({breakdown})")
+            elif not to_delete:
+                click.echo("  All code up to date")
         else:
             click.echo("  No code files found")
 
@@ -1163,7 +1254,6 @@ def daemon_start(path: Path, interval: str):
     pid_file.write_text(str(os.getpid()))
 
     # Redirect output to log file
-    # Note: log_fd is intentionally kept open for the lifetime of the daemon
     log_fd = open(log_file, "a")
     os.dup2(log_fd.fileno(), sys.stdout.fileno())
     os.dup2(log_fd.fileno(), sys.stderr.fileno())
@@ -1171,9 +1261,20 @@ def daemon_start(path: Path, interval: str):
     import time
     from datetime import datetime
 
+    # Set up signal handler for clean shutdown
+    running = True
+
+    def handle_shutdown(signum, frame):
+        nonlocal running
+        running = False
+        print(f"\n[{datetime.now().isoformat()}] Received signal {signum}, shutting down...")
+
+    signal.signal(signal.SIGTERM, handle_shutdown)
+    signal.signal(signal.SIGINT, handle_shutdown)
+
     print(f"\n[{datetime.now().isoformat()}] Daemon started (interval: {interval})")
 
-    while True:
+    while running:
         try:
             print(f"[{datetime.now().isoformat()}] Running sync...")
 
@@ -1196,7 +1297,17 @@ def daemon_start(path: Path, interval: str):
         except Exception as e:
             print(f"[{datetime.now().isoformat()}] Error: {e}")
 
-        time.sleep(interval_seconds)
+        # Sleep in small increments to respond to signals faster
+        for _ in range(interval_seconds):
+            if not running:
+                break
+            time.sleep(1)
+
+    # Clean up
+    print(f"[{datetime.now().isoformat()}] Daemon stopped")
+    log_fd.close()
+    if pid_file.exists():
+        pid_file.unlink()
 
 
 @daemon.command("stop")
@@ -2026,7 +2137,7 @@ def update(check: bool):
     from urllib.request import urlopen
     from urllib.error import URLError
 
-    current = "0.2.6"
+    current = "0.2.8"
 
     click.echo(f"Current version: {current}")
     click.echo("Checking PyPI for updates...")

{ragtime_cli-0.2.6 → ragtime_cli-0.2.8}/src/config.py

@@ -33,6 +33,18 @@ class CodeConfig:
         "**/build/**",
         "**/dist/**",
         "**/.dart_tool/**",
+        # Generated code (Prisma, GraphQL, OpenAPI, etc.)
+        "**/generated/**",
+        "**/*.generated.*",
+        "**/*.g.dart",
+        # TypeScript declaration files (often auto-generated)
+        "**/*.d.ts",
+        # Test files (usually not needed in search)
+        "**/__tests__/**",
+        "**/*.test.*",
+        "**/*.spec.*",
+        # Python init files (rarely have searchable content)
+        "**/__init__.py",
     ])
 
 

{ragtime_cli-0.2.6 → ragtime_cli-0.2.8}/src/db.py

@@ -154,14 +154,76 @@ class RagtimeDB:
 
     def stats(self) -> dict:
         """Get index statistics."""
-        count = self.collection.count()
+        try:
+            count = self.collection.count()
+
+            # Count by type - only retrieve IDs, not full documents
+            docs_result = self.collection.get(where={"type": "docs"}, include=[])
+            code_result = self.collection.get(where={"type": "code"}, include=[])
+
+            docs_count = len(docs_result["ids"])
+            code_count = len(code_result["ids"])
+
+            return {
+                "total": count,
+                "docs": docs_count,
+                "code": code_count,
+            }
+        except Exception:
+            # Return zeros if collection is corrupted or unavailable
+            return {
+                "total": 0,
+                "docs": 0,
+                "code": 0,
+            }
+
+    def get_indexed_files(self, type_filter: str | None = None) -> dict[str, float]:
+        """
+        Get all indexed files and their modification times.
+
+        Args:
+            type_filter: "code" or "docs" (None = both)
+
+        Returns:
+            Dict mapping file paths to their indexed mtime
+        """
+        where = {"type": type_filter} if type_filter else None
+        results = self.collection.get(where=where, include=["metadatas"])
+
+        files: dict[str, float] = {}
+        for meta in results["metadatas"]:
+            file_path = meta.get("file", "")
+            mtime = meta.get("mtime", 0.0)
+            # For code files, multiple entries per file - keep max mtime
+            if file_path not in files or mtime > files[file_path]:
+                files[file_path] = mtime
+
+        return files
+
+    def delete_by_file(self, file_paths: list[str], type_filter: str | None = None) -> int:
+        """
+        Delete all entries for the given file paths.
+
+        Args:
+            file_paths: List of file paths to remove
+            type_filter: "code" or "docs" (None = both)
+
+        Returns:
+            Number of entries deleted
+        """
+        if not file_paths:
+            return 0
+
+        # Build where clause
+        where = {"file": {"$in": file_paths}}
+        if type_filter:
+            where = {"$and": [{"file": {"$in": file_paths}}, {"type": type_filter}]}
+
+        # Get IDs to delete
+        results = self.collection.get(where=where)
+        ids = results["ids"]
 
-        # Count by type
-        docs_count = len(self.collection.get(where={"type": "docs"})["ids"])
-        code_count = len(self.collection.get(where={"type": "code"})["ids"])
+        if ids:
+            self.collection.delete(ids=ids)
 
-        return {
-            "total": count,
-            "docs": docs_count,
-            "code": code_count,
-        }
+        return len(ids)

{ragtime_cli-0.2.6 → ragtime_cli-0.2.8}/src/indexers/code.py

@@ -6,6 +6,7 @@ This allows searching for specific code constructs like "useAsyncState" or "JWTM
 """
 
 import ast
+import os
 import re
 from fnmatch import fnmatch
 from pathlib import Path
@@ -32,6 +33,7 @@ class CodeEntry:
     symbol_type: str       # function, class, interface, component, etc.
     line_number: int       # Line where symbol starts
     docstring: str | None = None  # Extracted docstring/JSDoc
+    mtime: float | None = None    # File modification time for incremental indexing
 
     def to_metadata(self) -> dict:
         """Convert to ChromaDB metadata dict."""
@@ -42,6 +44,7 @@ class CodeEntry:
             "symbol_name": self.symbol_name,
             "symbol_type": self.symbol_type,
             "line": self.line_number,
+            "mtime": self.mtime or 0.0,
         }
 
 
@@ -92,14 +95,21 @@ def discover_code_files(
                     rel_path = str(path)
 
                 for ex in exclude:
-                    # Handle ** patterns by checking if pattern appears in path
+                    # Handle ** patterns
                     if "**" in ex:
-                        # Convert glob to a simpler check: **/node_modules/** means
-                        # any path containing /node_modules/ segment
-                        core_pattern = ex.replace("**", "").strip("/")
-                        if core_pattern and f"/{core_pattern}/" in f"/{rel_path}/":
-                            skip = True
-                            break
+                        if ex.endswith("/**"):
+                            # Directory pattern: **/node_modules/** or **/generated/**
+                            # Extract the directory name to match as path segment
+                            dir_pattern = ex.replace("**/", "").replace("/**", "")
+                            if f"/{dir_pattern}/" in f"/{rel_path}/":
+                                skip = True
+                                break
+                        else:
+                            # File pattern: **/*.d.ts, **/*.test.*, **/*.generated.*
+                            file_pattern = ex.replace("**/", "")
+                            if fnmatch(path.name, file_pattern):
+                                skip = True
+                                break
                     elif fnmatch(rel_path, ex) or fnmatch(path.name, ex):
                         skip = True
                         break
@@ -239,23 +249,38 @@ def index_typescript_file(file_path: Path, content: str) -> list[CodeEntry]:
     entries = []
     lines = content.split("\n")
 
-    # Patterns for different constructs
+    # Patterns for different constructs (exported and non-exported)
     patterns = [
         # Exported functions
         (r'export\s+(?:default\s+)?(?:async\s+)?function\s+(\w+)\s*(?:<[^>]+>)?\s*\(([^)]*)\)(?:\s*:\s*([^\{]+))?',
          "function"),
+        # Non-exported functions (top-level, not inside class/object)
+        (r'^(?:async\s+)?function\s+(\w+)\s*(?:<[^>]+>)?\s*\(',
+         "function"),
         # Arrow function exports
         (r'export\s+const\s+(\w+)\s*(?::\s*[^=]+)?\s*=\s*(?:async\s+)?\([^)]*\)\s*(?::\s*[^=]+)?\s*=>',
          "function"),
+        # Non-exported arrow functions (top-level const)
+        (r'^const\s+(\w+)\s*(?::\s*[^=]+)?\s*=\s*(?:async\s+)?\([^)]*\)\s*(?::\s*[^=]+)?\s*=>',
+         "function"),
         # Class exports
         (r'export\s+(?:default\s+)?class\s+(\w+)(?:\s+extends\s+(\w+))?(?:\s+implements\s+([^{]+))?',
          "class"),
+        # Non-exported classes
+        (r'^class\s+(\w+)(?:\s+extends\s+(\w+))?(?:\s+implements\s+([^{]+))?',
+         "class"),
         # Interface exports
         (r'export\s+(?:default\s+)?interface\s+(\w+)(?:<[^>]+>)?(?:\s+extends\s+([^{]+))?',
          "interface"),
+        # Non-exported interfaces
+        (r'^interface\s+(\w+)(?:<[^>]+>)?(?:\s+extends\s+([^{]+))?',
+         "interface"),
         # Type exports
         (r'export\s+type\s+(\w+)(?:<[^>]+>)?\s*=',
          "type"),
+        # Non-exported types
+        (r'^type\s+(\w+)(?:<[^>]+>)?\s*=',
+         "type"),
         # Const exports (useful for config objects, composables, etc.)
         (r'export\s+const\s+(\w+)\s*(?::\s*([^=]+))?\s*=\s*(?!.*=>)',
          "constant"),
@@ -380,8 +405,9 @@ def index_dart_file(file_path: Path, content: str) -> list[CodeEntry]:
         # Class definitions
         (r'(?:abstract\s+)?class\s+(\w+)(?:<[^>]+>)?(?:\s+extends\s+(\w+))?(?:\s+with\s+([^{]+))?(?:\s+implements\s+([^{]+))?',
          "class"),
-        # Function definitions
-        (r'(?:Future<[^>]+>|void|int|String|bool|double|dynamic|\w+)\s+(\w+)\s*(?:<[^>]+>)?\s*\(',
+        # Top-level function definitions - explicit return types to avoid matching variable declarations
+        # The re.match already anchors at start, \s* is prepended in loop
+        (r'(?:Future<[^>]+>|Stream<[^>]+>|void|int|String|bool|double|dynamic|List<[^>]+>|Map<[^>]+>|Set<[^>]+>)\s+(\w+)\s*(?:<[^>]+>)?\s*\(',
          "function"),
         # Mixins
         (r'mixin\s+(\w+)(?:\s+on\s+(\w+))?',
@@ -432,7 +458,8 @@ def index_file(file_path: Path) -> list[CodeEntry]:
     """
     try:
         content = file_path.read_text(encoding='utf-8')
-    except (IOError, UnicodeDecodeError):
+        mtime = os.path.getmtime(file_path)
+    except (IOError, UnicodeDecodeError, OSError):
         return []
 
     # Skip empty files
@@ -442,15 +469,21 @@ def index_file(file_path: Path) -> list[CodeEntry]:
     suffix = file_path.suffix.lower()
 
     if suffix == ".py":
-        return index_python_file(file_path, content)
+        entries = index_python_file(file_path, content)
     elif suffix in [".ts", ".tsx", ".js", ".jsx"]:
-        return index_typescript_file(file_path, content)
+        entries = index_typescript_file(file_path, content)
     elif suffix == ".vue":
-        return index_vue_file(file_path, content)
+        entries = index_vue_file(file_path, content)
     elif suffix == ".dart":
-        return index_dart_file(file_path, content)
+        entries = index_dart_file(file_path, content)
+    else:
+        return []
 
-    return []
+    # Set mtime on all entries from this file
+    for entry in entries:
+        entry.mtime = mtime
+
+    return entries
 
 
 def index_directory(

{ragtime_cli-0.2.6 → ragtime_cli-0.2.8}/src/indexers/docs.py

@@ -4,6 +4,7 @@ Docs indexer - parses markdown files with YAML frontmatter.
 Designed for .claude/memory/ style files but works with any markdown.
 """
 
+import os
 import re
 from pathlib import Path
 from dataclasses import dataclass
@@ -19,6 +20,7 @@ class DocEntry:
     category: str | None = None
     component: str | None = None
     title: str | None = None
+    mtime: float | None = None  # File modification time for incremental indexing
 
     def to_metadata(self) -> dict:
         """Convert to ChromaDB metadata dict."""
@@ -29,6 +31,7 @@ class DocEntry:
             "category": self.category or "",
             "component": self.component or "",
             "title": self.title or Path(self.file_path).stem,
+            "mtime": self.mtime or 0.0,
         }
 
 
@@ -61,7 +64,8 @@ def index_file(file_path: Path) -> DocEntry | None:
     """
     try:
         content = file_path.read_text(encoding='utf-8')
-    except (IOError, UnicodeDecodeError):
+        mtime = os.path.getmtime(file_path)
+    except (IOError, UnicodeDecodeError, OSError):
         return None
 
     metadata, body = parse_frontmatter(content)
@@ -77,6 +81,7 @@ def index_file(file_path: Path) -> DocEntry | None:
         category=metadata.get("category"),
         component=metadata.get("component"),
         title=metadata.get("title"),
+        mtime=mtime,
     )
 
 

{ragtime_cli-0.2.6 → ragtime_cli-0.2.8}/src/mcp_server.py

@@ -487,7 +487,7 @@ class RagtimeMCPServer:
                         "protocolVersion": "2024-11-05",
                         "serverInfo": {
                             "name": "ragtime",
-                            "version": "0.2.6",
+                            "version": "0.2.8",
                         },
                         "capabilities": {
                             "tools": {},
@@ -563,8 +563,18 @@ class RagtimeMCPServer:
                     sys.stdout.write(json.dumps(response) + "\n")
                     sys.stdout.flush()
 
-            except json.JSONDecodeError:
-                continue
+            except json.JSONDecodeError as e:
+                # Log error and send JSON-RPC error response
+                error_response = {
+                    "jsonrpc": "2.0",
+                    "id": None,
+                    "error": {
+                        "code": -32700,
+                        "message": f"Parse error: {e}",
+                    },
+                }
+                sys.stdout.write(json.dumps(error_response) + "\n")
+                sys.stdout.flush()
             except KeyboardInterrupt:
                 break
 

{ragtime_cli-0.2.6 → ragtime_cli-0.2.8}/src/memory.py

@@ -80,18 +80,23 @@ class Memory:
 
         if self.namespace == "app":
             if self.component:
-                return f"app/{self.component}/{self.id}-{slug}.md"
+                # Sanitize component to prevent path traversal
+                safe_component = self._slugify(self.component)
+                return f"app/{safe_component}/{self.id}-{slug}.md"
             return f"app/{self.id}-{slug}.md"
         elif self.namespace == "team":
             return f"team/{self.id}-{slug}.md"
         elif self.namespace.startswith("user-"):
-            username = self.namespace.replace("user-", "")
+            # Sanitize username to prevent path traversal
+            username = self._slugify(self.namespace.replace("user-", ""))
             return f"users/{username}/{self.id}-{slug}.md"
         elif self.namespace.startswith("branch-"):
             branch_slug = self._slugify(self.namespace.replace("branch-", ""))
             return f"branches/{branch_slug}/{self.id}-{slug}.md"
         else:
-            return f"other/{self.namespace}/{self.id}-{slug}.md"
+            # Sanitize namespace to prevent path traversal
+            safe_namespace = self._slugify(self.namespace)
+            return f"other/{safe_namespace}/{self.id}-{slug}.md"
 
     @staticmethod
     def _slugify(text: str) -> str:
@@ -376,9 +381,25 @@ class MemoryStore:
 
     def _cleanup_empty_dirs(self, dir_path: Path) -> None:
         """Remove empty directories up to memory_dir."""
-        while dir_path != self.memory_dir and dir_path.exists():
-            if not any(dir_path.iterdir()):
-                dir_path.rmdir()
-                dir_path = dir_path.parent
-            else:
-                break
+        # Resolve paths to handle symlinks and ensure we stay within bounds
+        try:
+            dir_path = dir_path.resolve()
+            memory_dir_resolved = self.memory_dir.resolve()
+        except OSError:
+            return  # Can't resolve paths, bail out safely
+
+        # Ensure dir_path is actually under memory_dir
+        try:
+            dir_path.relative_to(memory_dir_resolved)
+        except ValueError:
+            return  # dir_path is not under memory_dir, bail out
+
+        while dir_path != memory_dir_resolved and dir_path.exists():
+            try:
+                if not any(dir_path.iterdir()):
+                    dir_path.rmdir()
+                    dir_path = dir_path.parent.resolve()
+                else:
+                    break
+            except OSError:
+                break  # Permission error or other issue, stop cleanup