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

{ragtime_cli-0.2.7/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.7
+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.7 → ragtime_cli-0.2.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ragtime-cli"
-version = "0.2.7"
+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.7 → 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.7
+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.7 → 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.7")
+@click.version_option(version="0.2.8")
 def main():
     """Ragtime - semantic search over code and documentation."""
     pass
@@ -1254,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())
@@ -1262,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...")
 
@@ -1287,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")
@@ -2117,7 +2137,7 @@ def update(check: bool):
     from urllib.request import urlopen
     from urllib.error import URLError
 
-    current = "0.2.7"
+    current = "0.2.8"
 
     click.echo(f"Current version: {current}")
     click.echo("Checking PyPI for updates...")

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

@@ -154,17 +154,28 @@ class RagtimeDB:
 
     def stats(self) -> dict:
         """Get index statistics."""
-        count = self.collection.count()
-
-        # Count by type
-        docs_count = len(self.collection.get(where={"type": "docs"})["ids"])
-        code_count = len(self.collection.get(where={"type": "code"})["ids"])
-
-        return {
-            "total": count,
-            "docs": docs_count,
-            "code": code_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]:
         """

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

@@ -249,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"),
@@ -390,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+))?',

{ragtime_cli-0.2.7 → 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.7 → 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