ragtime-cli 0.2.11__tar.gz → 0.2.13__tar.gz

{ragtime_cli-0.2.11/ragtime_cli.egg-info → ragtime_cli-0.2.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ragtime-cli
-Version: 0.2.11
+Version: 0.2.13
 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.11 → ragtime_cli-0.2.13}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ragtime-cli"
-version = "0.2.11"
+version = "0.2.13"
 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.11 → ragtime_cli-0.2.13/ragtime_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ragtime-cli
-Version: 0.2.11
+Version: 0.2.13
 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.11 → ragtime_cli-0.2.13}/src/cli.py

@@ -734,6 +734,72 @@ def reindex(path: Path):
     click.echo(f"✓ Reindexed {count} memory files")
 
 
+@main.command()
+@click.option("--path", type=click.Path(exists=True, path_type=Path), default=".")
+@click.option("--dry-run", is_flag=True, help="Show what would be removed")
+def dedupe(path: Path, dry_run: bool):
+    """Clean up index: remove duplicates and orphaned entries.
+
+    - Removes duplicate entries (keeps one per file path)
+    - Removes orphaned entries (files that no longer exist on disk)
+    """
+    path = Path(path).resolve()
+    db = get_db(path)
+    memory_dir = path / ".ragtime"
+
+    # Get all entries with their file paths
+    results = db.collection.get(include=["metadatas"])
+
+    # Group by file path and track orphans
+    by_file: dict[str, list[str]] = {}
+    orphans: list[str] = []
+
+    for i, mem_id in enumerate(results["ids"]):
+        file_path = results["metadatas"][i].get("file", "")
+        entry_type = results["metadatas"][i].get("type", "")
+
+        # Skip docs/code entries - only clean up memory entries
+        if entry_type in ("docs", "code"):
+            continue
+
+        if not file_path:
+            orphans.append(mem_id)
+            continue
+
+        # Check if file exists on disk
+        full_path = memory_dir / file_path
+        if not full_path.exists():
+            orphans.append(mem_id)
+            if dry_run:
+                click.echo(f"  Orphan: {file_path} (file missing)")
+            continue
+
+        if file_path not in by_file:
+            by_file[file_path] = []
+        by_file[file_path].append(mem_id)
+
+    # Find duplicates (keep first, remove rest)
+    duplicates: list[str] = []
+    for file_path, ids in by_file.items():
+        if len(ids) > 1:
+            duplicates.extend(ids[1:])
+            if dry_run:
+                click.echo(f"  Duplicate: {file_path} ({len(ids)} copies, removing {len(ids) - 1})")
+
+    to_remove = orphans + duplicates
+
+    if not to_remove:
+        click.echo("✓ Index is clean (no duplicates or orphans)")
+        return
+
+    if dry_run:
+        click.echo(f"\nWould remove {len(orphans)} orphans + {len(duplicates)} duplicates = {len(to_remove)} entries")
+        click.echo("Run without --dry-run to remove them")
+    else:
+        db.delete(to_remove)
+        click.echo(f"✓ Removed {len(orphans)} orphans + {len(duplicates)} duplicates = {len(to_remove)} entries")
+
+
 @main.command("new-branch")
 @click.argument("issue", type=int)
 @click.option("--path", type=click.Path(exists=True, path_type=Path), default=".")

{ragtime_cli-0.2.11 → ragtime_cli-0.2.13}/src/mcp_server.py

@@ -493,7 +493,7 @@ class RagtimeMCPServer:
                         "protocolVersion": "2024-11-05",
                         "serverInfo": {
                             "name": "ragtime",
-                            "version": "0.2.11",
+                            "version": "0.2.13",
                         },
                         "capabilities": {
                             "tools": {},

{ragtime_cli-0.2.11 → ragtime_cli-0.2.13}/src/memory.py

@@ -10,6 +10,7 @@ from dataclasses import dataclass, field
 from datetime import date
 from typing import Optional
 import uuid
+import hashlib
 import re
 import yaml
 
@@ -109,42 +110,102 @@ class Memory:
         slug = re.sub(r'[-\s]+', '-', slug).strip('-')
         return slug[:40]  # Limit length
 
+    @classmethod
+    def _infer_metadata_from_path(cls, relative_path: str) -> dict:
+        """
+        Infer namespace, component, and type from folder structure.
+
+        Supports:
+          app/{component}/*.md → namespace=app, component={component}
+          app/*.md → namespace=app
+          team/*.md → namespace=team
+          users/{username}/*.md → namespace=user-{username}
+          branches/{branch}/*.md → namespace=branch-{branch}
+        """
+        parts = relative_path.replace("\\", "/").split("/")
+        metadata = {}
+
+        if len(parts) >= 1:
+            first = parts[0]
+            if first == "app":
+                metadata["namespace"] = "app"
+                if len(parts) >= 3:  # app/{component}/file.md
+                    metadata["component"] = parts[1]
+            elif first == "team":
+                metadata["namespace"] = "team"
+            elif first == "users" and len(parts) >= 2:
+                metadata["namespace"] = f"user-{parts[1]}"
+            elif first == "branches" and len(parts) >= 2:
+                metadata["namespace"] = f"branch-{parts[1]}"
+
+        return metadata
+
     @classmethod
     def from_file(cls, path: Path, relative_to: Optional[Path] = None) -> "Memory":
         """
         Parse a memory from a markdown file with YAML frontmatter.
 
+        If no frontmatter exists, infers metadata from folder structure.
+
         Args:
             path: Full path to the markdown file
             relative_to: Base directory to compute relative path from (for indexing)
         """
         text = path.read_text()
 
+        # Compute relative path for inference and indexing
+        file_path = None
+        if relative_to:
+            try:
+                file_path = str(path.relative_to(relative_to))
+            except ValueError:
+                pass
+
+        # Handle files without frontmatter - infer from path
         if not text.startswith("---"):
-            raise ValueError(f"No YAML frontmatter found in {path}")
+            inferred = cls._infer_metadata_from_path(file_path or str(path))
+            # Generate stable ID from path
+            memory_id = hashlib.sha256((file_path or str(path)).encode()).hexdigest()[:8]
+
+            return cls(
+                id=memory_id,
+                content=text.strip(),
+                namespace=inferred.get("namespace", "app"),
+                type=inferred.get("type", "note"),
+                component=inferred.get("component"),
+                source="file",
+                _file_path=file_path,
+            )
 
         # Split frontmatter and content
         parts = text.split("---", 2)
         if len(parts) < 3:
             raise ValueError(f"Invalid frontmatter format in {path}")
 
-        frontmatter = yaml.safe_load(parts[1])
+        frontmatter = yaml.safe_load(parts[1]) or {}
         content = parts[2].strip()
 
-        # Compute relative file path for indexing
-        file_path = None
-        if relative_to:
-            try:
-                file_path = str(path.relative_to(relative_to))
-            except ValueError:
-                pass  # path not relative to base, will regenerate
+        # Infer missing metadata from folder structure
+        inferred = cls._infer_metadata_from_path(file_path or str(path))
+
+        # Use frontmatter ID if present, otherwise derive stable ID from file path
+        # This ensures reindex is idempotent - same file always gets same ID
+        if "id" in frontmatter:
+            memory_id = frontmatter["id"]
+        elif file_path:
+            # Stable hash of relative path
+            memory_id = hashlib.sha256(file_path.encode()).hexdigest()[:8]
+        else:
+            # Fallback: hash of absolute path
+            memory_id = hashlib.sha256(str(path).encode()).hexdigest()[:8]
 
         return cls(
-            id=frontmatter.get("id", str(uuid.uuid4())[:8]),
+            id=memory_id,
             content=content,
-            namespace=frontmatter.get("namespace", "app"),
-            type=frontmatter.get("type", "unknown"),
-            component=frontmatter.get("component"),
+            # Use frontmatter if present, fall back to inferred, then defaults
+            namespace=frontmatter.get("namespace") or inferred.get("namespace", "app"),
+            type=frontmatter.get("type") or inferred.get("type", "note"),
+            component=frontmatter.get("component") or inferred.get("component"),
             confidence=frontmatter.get("confidence", "medium"),
             confidence_reason=frontmatter.get("confidence_reason"),
             source=frontmatter.get("source", "file"),
@@ -411,7 +472,9 @@ class MemoryStore:
         """
         Reindex all memory files.
 
-        Scans .ragtime/ and indexes any files not in ChromaDB.
+        Scans .ragtime/ and indexes files. Removes old entries for each file
+        before upserting to prevent duplicates from ID changes.
+
         Returns count of files indexed.
         """
         if not self.memory_dir.exists():
@@ -420,7 +483,13 @@ class MemoryStore:
         count = 0
         for md_file in self.memory_dir.rglob("*.md"):
             try:
-                # Pass memory_dir so the actual file path is stored, not regenerated
+                # Compute relative path for this file
+                rel_path = str(md_file.relative_to(self.memory_dir))
+
+                # Delete any existing entries for this file path (handles ID changes)
+                self.db.delete_by_file([rel_path])
+
+                # Parse and index with stable ID
                 memory = Memory.from_file(md_file, relative_to=self.memory_dir)
                 self.db.upsert(
                     ids=[memory.id],