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

{ragtime_cli-0.2.12/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.12
+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.12 → ragtime_cli-0.2.13}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ragtime-cli"
-version = "0.2.12"
+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.12 → 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.12
+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.12 → ragtime_cli-0.2.13}/src/cli.py

@@ -736,47 +736,68 @@ def reindex(path: Path):
 
 @main.command()
 @click.option("--path", type=click.Path(exists=True, path_type=Path), default=".")
-@click.option("--dry-run", is_flag=True, help="Show duplicates without removing them")
+@click.option("--dry-run", is_flag=True, help="Show what would be removed")
 def dedupe(path: Path, dry_run: bool):
-    """Remove duplicate entries from the index.
+    """Clean up index: remove duplicates and orphaned entries.
 
-    Keeps one entry per unique file path, removing duplicates created
-    by older versions of reindex that generated random IDs.
+    - 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
+    # 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", "")
-        if file_path:
-            if file_path not in by_file:
-                by_file[file_path] = []
-            by_file[file_path].append(mem_id)
+        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
 
-    # Find duplicates
-    duplicates_to_remove = []
+        # 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:
-            # Keep the first one, remove the rest
-            duplicates_to_remove.extend(ids[1:])
+            duplicates.extend(ids[1:])
             if dry_run:
-                click.echo(f"  {file_path}: {len(ids)} copies (would remove {len(ids) - 1})")
+                click.echo(f"  Duplicate: {file_path} ({len(ids)} copies, removing {len(ids) - 1})")
+
+    to_remove = orphans + duplicates
 
-    if not duplicates_to_remove:
-        click.echo("✓ No duplicates found")
+    if not to_remove:
+        click.echo("✓ Index is clean (no duplicates or orphans)")
         return
 
     if dry_run:
-        click.echo(f"\nWould remove {len(duplicates_to_remove)} duplicate entries")
+        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(duplicates_to_remove)
-        click.echo(f"✓ Removed {len(duplicates_to_remove)} duplicate entries")
+        db.delete(to_remove)
+        click.echo(f"✓ Removed {len(orphans)} orphans + {len(duplicates)} duplicates = {len(to_remove)} entries")
 
 
 @main.command("new-branch")

{ragtime_cli-0.2.12 → 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.12",
+                            "version": "0.2.13",
                         },
                         "capabilities": {
                             "tools": {},

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

@@ -110,35 +110,83 @@ 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
@@ -154,9 +202,10 @@ class Memory:
         return cls(
             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"),
@@ -423,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():
@@ -432,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],