ragtime-cli 0.1.2__tar.gz → 0.2.1__tar.gz

{ragtime_cli-0.1.2/ragtime_cli.egg-info → ragtime_cli-0.2.1}/PKG-INFO

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

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

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

@@ -5,6 +5,9 @@ Ragtime CLI - semantic search and memory storage.
 from pathlib import Path
 import subprocess
 import click
+import os
+import signal
+import sys
 
 from .db import RagtimeDB
 from .config import RagtimeConfig, init_config
@@ -27,7 +30,6 @@ def get_memory_store(project_path: Path) -> MemoryStore:
 def get_author() -> str:
     """Get the current developer's username."""
     try:
-        # Try gh CLI first
         result = subprocess.run(
             ["gh", "api", "user", "--jq", ".login"],
             capture_output=True,
@@ -40,7 +42,6 @@ def get_author() -> str:
         pass
 
     try:
-        # Fall back to git config
         result = subprocess.run(
             ["git", "config", "user.name"],
             capture_output=True,
@@ -122,8 +123,50 @@ def get_current_branch(path: Path) -> str | None:
     return None
 
 
+def get_branch_slug(ref: str) -> str:
+    """Convert a git ref to a branch slug for folder naming."""
+    if ref.startswith("origin/"):
+        ref = ref[7:]
+    return ref.replace("/", "-")
+
+
+def get_remote_branches_with_ragtime(path: Path) -> list[str]:
+    """Get list of remote branches that have .ragtime/branches/ content."""
+    try:
+        # Get all remote branches
+        result = subprocess.run(
+            ["git", "branch", "-r", "--format=%(refname:short)"],
+            cwd=path,
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+        if result.returncode != 0:
+            return []
+
+        branches = []
+        for ref in result.stdout.strip().split("\n"):
+            if not ref or ref.endswith("/HEAD"):
+                continue
+
+            # Check if this branch has ragtime content
+            check = subprocess.run(
+                ["git", "ls-tree", "-r", "--name-only", ref, ".ragtime/branches/"],
+                cwd=path,
+                capture_output=True,
+                text=True,
+                timeout=5,
+            )
+            if check.returncode == 0 and check.stdout.strip():
+                branches.append(ref)
+
+        return branches
+    except Exception:
+        return []
+
+
 @click.group()
-@click.version_option(version="0.1.2")
+@click.version_option(version="0.2.1")
 def main():
     """Ragtime - semantic search over code and documentation."""
     pass
@@ -140,19 +183,42 @@ def init(path: Path):
     click.echo(f"  Code paths: {config.code.paths}")
     click.echo(f"  Languages: {config.code.languages}")
 
-    # Create memory directory structure
-    memory_dir = path / ".claude" / "memory"
-    (memory_dir / "app").mkdir(parents=True, exist_ok=True)
-    (memory_dir / "team").mkdir(parents=True, exist_ok=True)
-    (memory_dir / "branches").mkdir(parents=True, exist_ok=True)
-    click.echo(f"\nCreated .claude/memory/ structure")
+    # Create directory structure
+    ragtime_dir = path / ".ragtime"
+    (ragtime_dir / "app").mkdir(parents=True, exist_ok=True)
+    (ragtime_dir / "team").mkdir(parents=True, exist_ok=True)
+    (ragtime_dir / "branches").mkdir(parents=True, exist_ok=True)
+    (ragtime_dir / "archive" / "branches").mkdir(parents=True, exist_ok=True)
+
+    # Create .gitkeep files
+    for subdir in ["app", "team", "archive/branches"]:
+        gitkeep = ragtime_dir / subdir / ".gitkeep"
+        if not gitkeep.exists():
+            gitkeep.touch()
+
+    # Create .gitignore for synced branches (dot-prefixed)
+    gitignore_path = ragtime_dir / ".gitignore"
+    gitignore_content = """# Synced branches from teammates (dot-prefixed)
+branches/.*
+
+# Index database
+index/
+"""
+    gitignore_path.write_text(gitignore_content)
+
+    click.echo(f"\nCreated .ragtime/ structure:")
+    click.echo(f"  app/       - Graduated knowledge (tracked)")
+    click.echo(f"  team/      - Team conventions (tracked)")
+    click.echo(f"  branches/  - Active branches (yours tracked, synced gitignored)")
+    click.echo(f"  archive/   - Completed branches (tracked)")
 
     # Check for ghp-cli
     if check_ghp_installed():
-        click.echo(f"\n✓ ghp-cli detected - will use for issue lookups")
+        click.echo(f"\n✓ ghp-cli detected")
+        click.echo(f"  Run 'ragtime setup-ghp' to enable auto-context on 'ghp start'")
     else:
-        click.echo(f"\n• ghp-cli not found - will use gh CLI for issue lookups")
-        click.echo(f"  Install ghp for enhanced workflow: pip install ghp-cli")
+        click.echo(f"\n• ghp-cli not found")
+        click.echo(f"  Install for enhanced workflow: npm install -g @bretwardjames/ghp-cli")
 
 
 @main.command()
@@ -172,7 +238,6 @@ def index(path: Path, index_type: str, clear: bool):
         else:
             db.clear(type_filter=index_type)
 
-    # Index docs
     if index_type in ("all", "docs"):
         total_entries = []
         for docs_path in config.docs.paths:
@@ -192,24 +257,17 @@ def index(path: Path, index_type: str, clear: bool):
             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 documents found")
 
-    # Index code
     if index_type in ("all", "code"):
-        # Build exclude list that includes docs paths
         code_exclude = list(config.code.exclude)
         for docs_path in config.docs.paths:
             code_exclude.append(f"**/{docs_path}/**")
-
         click.echo("Code indexing not yet implemented")
-        click.echo(f"  Will exclude docs paths: {config.docs.paths}")
-        # TODO: Implement code indexer with code_exclude
 
-    # Show stats
     stats = db.stats()
     click.echo(f"\nIndex stats: {stats['total']} total ({stats['docs']} docs, {stats['code']} code)")
 
@@ -219,9 +277,11 @@ def index(path: Path, index_type: str, clear: bool):
 @click.option("--path", type=click.Path(exists=True, path_type=Path), default=".")
 @click.option("--type", "type_filter", type=click.Choice(["all", "docs", "code"]), default="all")
 @click.option("--namespace", "-n", help="Filter by namespace")
+@click.option("--include-archive", is_flag=True, help="Also search archived branches")
 @click.option("--limit", "-l", default=5, help="Max results")
 @click.option("--verbose", "-v", is_flag=True, help="Show full content")
-def search(query: str, path: Path, type_filter: str, namespace: str, limit: int, verbose: bool):
+def search(query: str, path: Path, type_filter: str, namespace: str,
+           include_archive: bool, limit: int, verbose: bool):
     """Search indexed content."""
     path = Path(path).resolve()
     db = get_db(path)
@@ -253,7 +313,6 @@ def search(query: str, path: Path, type_filter: str, namespace: str, limit: int,
         if verbose:
             click.echo(f"\n{result['content'][:500]}...")
         else:
-            # Show first 150 chars
             preview = result["content"][:150].replace("\n", " ")
             click.echo(f"    {preview}...")
 
@@ -368,11 +427,7 @@ def remember(content: str, path: Path, namespace: str, memory_type: str,
               type=click.Choice(["handoff", "document", "plan", "notes"]),
               help="Document type")
 def store_doc(file: Path, path: Path, namespace: str, doc_type: str):
-    """Store a document verbatim (like handoff.md).
-
-    Example:
-        ragtime store-doc .claude/handoff.md --namespace branch-feature/auth
-    """
+    """Store a document verbatim (like handoff.md)."""
     path = Path(path).resolve()
     file = Path(file).resolve()
     store = get_memory_store(path)
@@ -389,11 +444,7 @@ def store_doc(file: Path, path: Path, namespace: str, doc_type: str):
 @click.option("--path", type=click.Path(exists=True, path_type=Path), default=".")
 @click.confirmation_option(prompt="Are you sure you want to delete this memory?")
 def forget(memory_id: str, path: Path):
-    """Delete a memory by ID.
-
-    Example:
-        ragtime forget abc123
-    """
+    """Delete a memory by ID."""
     path = Path(path).resolve()
     store = get_memory_store(path)
 
@@ -410,14 +461,7 @@ def forget(memory_id: str, path: Path):
               type=click.Choice(["high", "medium", "low"]),
               help="Confidence level for graduated memory")
 def graduate(memory_id: str, path: Path, confidence: str):
-    """Graduate a branch memory to app namespace.
-
-    Copies the memory to app namespace with high confidence
-    and marks the original as graduated.
-
-    Example:
-        ragtime graduate abc123
-    """
+    """Graduate a branch memory to app namespace."""
     path = Path(path).resolve()
     store = get_memory_store(path)
 
@@ -443,13 +487,7 @@ def graduate(memory_id: str, path: Path, confidence: str):
 @click.option("--verbose", "-v", is_flag=True, help="Show full content")
 def list_memories(path: Path, namespace: str, type_filter: str, status: str,
                   component: str, limit: int, verbose: bool):
-    """List memories with optional filters.
-
-    Examples:
-        ragtime memories --namespace app
-        ragtime memories --namespace branch-* --status active
-        ragtime memories --type decision --component auth
-    """
+    """List memories with optional filters."""
     path = Path(path).resolve()
     store = get_memory_store(path)
 
@@ -485,10 +523,7 @@ def list_memories(path: Path, namespace: str, type_filter: str, status: str,
 @main.command()
 @click.option("--path", type=click.Path(exists=True, path_type=Path), default=".")
 def reindex(path: Path):
-    """Reindex all memory files.
-
-    Scans .claude/memory/ and adds any files not in the index.
-    """
+    """Reindex all memory files."""
     path = Path(path).resolve()
     store = get_memory_store(path)
 
@@ -505,22 +540,15 @@ def reindex(path: Path):
 def new_branch(issue: int, path: Path, content: str, issue_json: str, branch: str):
     """Initialize a branch context from a GitHub issue.
 
-    Creates .claude/memory/branches/{branch-slug}/context.md with either:
+    Creates .ragtime/branches/{branch-slug}/context.md with either:
     - Provided content (from --content flag, e.g., LLM-generated plan)
     - Auto-generated scaffold from issue metadata (fallback)
-
-    Examples:
-        ragtime new-branch 42                         # Scaffold from issue #42
-        ragtime new-branch 42 --content "..."         # Use provided content
-        ragtime new-branch 42 --issue-json '{...}'    # Use JSON from ghp hook
-        ragtime new-branch 42 --branch my-feat        # Specify branch name
     """
     import json
     from datetime import date
 
     path = Path(path).resolve()
 
-    # Determine branch name
     if not branch:
         branch = get_current_branch(path)
         if not branch or branch in ("main", "master"):
@@ -529,23 +557,21 @@ def new_branch(issue: int, path: Path, content: str, issue_json: str, branch: st
 
     # Create branch slug for folder name
     branch_slug = branch.replace("/", "-")
-    branch_dir = path / ".claude" / "memory" / "branches" / branch_slug
+    branch_dir = path / ".ragtime" / "branches" / branch_slug
     branch_dir.mkdir(parents=True, exist_ok=True)
 
     context_file = branch_dir / "context.md"
 
     if content:
-        # Use provided content directly
         context_file.write_text(content)
         click.echo(f"✓ Created context.md with provided content")
         click.echo(f"  Path: {context_file.relative_to(path)}")
         return
 
-    # Get issue data from JSON, ghp, or gh
+    # Get issue data
     issue_data = None
     source = None
 
-    # Use provided JSON if available (from ghp hook)
     if issue_json:
         try:
             issue_data = json.loads(issue_json)
@@ -554,30 +580,22 @@ def new_branch(issue: int, path: Path, content: str, issue_json: str, branch: st
             click.echo(f"✗ Invalid JSON: {e}", err=True)
             return
     else:
-        # Fall back to fetching from API
         click.echo(f"Fetching issue #{issue}...")
-
-        # Try ghp first if available
         if check_ghp_installed():
             issue_data = get_issue_from_ghp(issue, path)
             source = "ghp"
-
-        # Fall back to gh
         if not issue_data:
             issue_data = get_issue_from_gh(issue, path)
             source = "gh"
 
     if not issue_data:
         click.echo(f"✗ Could not fetch issue #{issue}", err=True)
-        click.echo("  Make sure you're in a git repo with GitHub remote")
         return
 
-    # Extract issue fields
     title = issue_data.get("title", f"Issue #{issue}")
     body = issue_data.get("body", "")
     labels = issue_data.get("labels", [])
 
-    # Format labels
     if labels:
         if isinstance(labels[0], dict):
             label_names = [l.get("name", "") for l in labels]
@@ -587,7 +605,6 @@ def new_branch(issue: int, path: Path, content: str, issue_json: str, branch: st
     else:
         labels_str = ""
 
-    # Generate scaffold context.md
     scaffold = f"""---
 type: context
 branch: {branch}
@@ -628,7 +645,6 @@ author: {get_author()}
     click.echo(f"✓ Created context.md from issue #{issue}")
     click.echo(f"  Path: {context_file.relative_to(path)}")
     click.echo(f"  Source: {source}")
-    click.echo(f"\nNext: Fill in the Plan section or use /start to generate it")
 
 
 # ============================================================================
@@ -657,13 +673,7 @@ def get_available_commands() -> list[str]:
 @click.argument("commands", nargs=-1)
 def install_commands(global_install: bool, workspace_install: bool, list_commands: bool,
                      force: bool, commands: tuple):
-    """Install Claude command templates.
-
-    Examples:
-        ragtime install --list                    # List available commands
-        ragtime install --workspace               # Install all to .claude/commands/
-        ragtime install --global remember recall  # Install specific commands globally
-    """
+    """Install Claude command templates."""
     available = get_available_commands()
 
     if list_commands:
@@ -672,7 +682,6 @@ def install_commands(global_install: bool, workspace_install: bool, list_command
             click.echo(f"  - {cmd}")
         return
 
-    # Determine target directory
     if global_install and workspace_install:
         click.echo("Error: Cannot specify both --global and --workspace", err=True)
         return
@@ -682,12 +691,9 @@ def install_commands(global_install: bool, workspace_install: bool, list_command
     elif workspace_install:
         target_dir = Path.cwd() / ".claude" / "commands"
     else:
-        # Default to workspace
         target_dir = Path.cwd() / ".claude" / "commands"
         click.echo("Installing to workspace (.claude/commands/)")
-        click.echo("Use --global for ~/.claude/commands/")
 
-    # Determine which commands to install
     if commands:
         to_install = [c for c in commands if c in available]
         not_found = [c for c in commands if c not in available]
@@ -700,13 +706,9 @@ def install_commands(global_install: bool, workspace_install: bool, list_command
         click.echo("No commands to install.")
         return
 
-    # Create target directory
     target_dir.mkdir(parents=True, exist_ok=True)
-
-    # Install each command
     commands_dir = get_commands_dir()
     installed = 0
-    skipped = 0
 
     for cmd in to_install:
         source = commands_dir / f"{cmd}.md"
@@ -715,45 +717,26 @@ def install_commands(global_install: bool, workspace_install: bool, list_command
         if target.exists() and not force:
             if click.confirm(f"  {cmd}.md exists. Overwrite?", default=False):
                 target.write_text(source.read_text())
-                click.echo(f"  ✓ {cmd}.md (overwritten)")
                 installed += 1
-            else:
-                click.echo(f"  - {cmd}.md (skipped)")
-                skipped += 1
         else:
             target.write_text(source.read_text())
             click.echo(f"  ✓ {cmd}.md")
             installed += 1
 
     click.echo(f"\nInstalled {installed} commands to {target_dir}")
-    if skipped:
-        click.echo(f"Skipped {skipped} existing commands (use --force to overwrite)")
-
-    # Remind about MCP server setup
-    click.echo("\nTo use these commands, add ragtime MCP server to your Claude config:")
-    click.echo('  "ragtime": {"command": "ragtime-mcp", "args": ["--path", "."]}')
 
 
 @main.command("setup-ghp")
 @click.option("--remove", is_flag=True, help="Remove ragtime hooks from ghp")
 def setup_ghp(remove: bool):
-    """Register ragtime hooks with ghp-cli.
-
-    Adds event hooks so ghp automatically creates context.md when starting issues.
-
-    Examples:
-        ragtime setup-ghp          # Register hooks
-        ragtime setup-ghp --remove # Remove hooks
-    """
+    """Register ragtime hooks with ghp-cli."""
     if not check_ghp_installed():
         click.echo("✗ ghp-cli not installed", err=True)
-        click.echo("  Install with: npm install -g @bretwardjames/ghp-cli")
         return
 
     hook_name = "ragtime-context"
 
     if remove:
-        # Remove the hook
         result = subprocess.run(
             ["ghp", "hooks", "remove", hook_name],
             capture_output=True,
@@ -762,13 +745,9 @@ def setup_ghp(remove: bool):
         if result.returncode == 0:
             click.echo(f"✓ Removed hook: {hook_name}")
         else:
-            if "not found" in result.stderr.lower():
-                click.echo(f"• Hook {hook_name} not registered")
-            else:
-                click.echo(f"✗ Failed to remove hook: {result.stderr}", err=True)
+            click.echo(f"• Hook {hook_name} not registered")
         return
 
-    # Check if hook already exists
     result = subprocess.run(
         ["ghp", "hooks", "show", hook_name],
         capture_output=True,
@@ -776,11 +755,9 @@ def setup_ghp(remove: bool):
     )
     if result.returncode == 0:
         click.echo(f"• Hook {hook_name} already registered")
-        click.echo("  Use --remove to unregister first")
         return
 
-    # Register the hook
-    # The command uses ${issue.number}, ${issue.json}, and ${branch} from ghp
+    # Updated path for .ragtime/
     hook_command = "ragtime new-branch ${issue.number} --issue-json '${issue.json}' --branch '${branch}'"
 
     result = subprocess.run(
@@ -798,7 +775,6 @@ def setup_ghp(remove: bool):
         click.echo(f"✓ Registered hook: {hook_name}")
         click.echo(f"  Event: issue-started")
         click.echo(f"  Action: Creates context.md from issue metadata")
-        click.echo(f"\nNow when you run 'ghp start <issue>', ragtime will auto-create context.md")
     else:
         click.echo(f"✗ Failed to register hook: {result.stderr}", err=True)
 
@@ -808,250 +784,376 @@ def setup_ghp(remove: bool):
 # ============================================================================
 
 
-def get_branch_slug(ref: str) -> str:
-    """Convert a git ref to a branch slug for folder naming."""
-    # Remove origin/ prefix if present
-    if ref.startswith("origin/"):
-        ref = ref[7:]
-    # Replace / with - for folder names
-    return ref.replace("/", "-")
-
-
 @main.command()
-@click.argument("ref")
 @click.option("--path", type=click.Path(exists=True, path_type=Path), default=".")
-def sync(ref: str, path: Path):
-    """Sync memories from a remote branch.
+@click.option("--quiet", "-q", is_flag=True, help="Suppress output (for automated runs)")
+@click.option("--auto-prune", is_flag=True, help="Automatically prune stale synced branches")
+def sync(path: Path, quiet: bool, auto_prune: bool):
+    """Sync memories from all remote branches.
 
-    Fetches .claude/memory/branches/* from the specified git ref
-    and copies to a local (unmerged) folder for searching.
-
-    Examples:
-        ragtime sync origin/jm/feature-auth
-        ragtime sync origin/sm/fix-bug
+    Fetches .ragtime/branches/* from remote branches and copies to
+    local dot-prefixed folders (e.g., .feature-branch/).
     """
     import shutil
-    import tempfile
 
     path = Path(path).resolve()
-    store = get_memory_store(path)
-
-    # Get the branch slug for folder naming
-    branch_slug = get_branch_slug(ref)
-    unmerged_dir = path / ".claude" / "memory" / "branches" / f"{branch_slug}(unmerged)"
+    branches_dir = path / ".ragtime" / "branches"
 
-    click.echo(f"Syncing memories from {ref}...")
+    if not quiet:
+        click.echo("Fetching remote branches...")
 
-    # Fetch the ref first
-    result = subprocess.run(
-        ["git", "fetch", "origin"],
+    # Fetch first
+    subprocess.run(
+        ["git", "fetch", "--quiet"],
         cwd=path,
         capture_output=True,
-        text=True,
     )
 
-    # Check if the ref exists
-    result = subprocess.run(
-        ["git", "rev-parse", "--verify", ref],
-        cwd=path,
-        capture_output=True,
-        text=True,
-    )
-    if result.returncode != 0:
-        click.echo(f"✗ Ref not found: {ref}", err=True)
-        return
-
-    commit_hash = result.stdout.strip()[:8]
-
-    # Check if there are memory files in that ref
-    result = subprocess.run(
-        ["git", "ls-tree", "-r", "--name-only", ref, ".claude/memory/branches/"],
-        cwd=path,
-        capture_output=True,
-        text=True,
-    )
-
-    if result.returncode != 0 or not result.stdout.strip():
-        click.echo(f"✗ No memories found in {ref}", err=True)
-        return
-
-    files = result.stdout.strip().split("\n")
-    click.echo(f"  Found {len(files)} memory files")
+    # Get current branch to exclude
+    current = get_current_branch(path)
+    current_slug = get_branch_slug(current) if current else None
 
-    # Clear existing unmerged folder if it exists
-    if unmerged_dir.exists():
-        shutil.rmtree(unmerged_dir)
+    # Find remote branches with ragtime content
+    remote_branches = get_remote_branches_with_ragtime(path)
 
-    unmerged_dir.mkdir(parents=True, exist_ok=True)
+    if not remote_branches and not quiet:
+        click.echo("No remote branches with ragtime content found.")
 
-    # Extract each file
     synced = 0
-    for file_path in files:
-        if not file_path.endswith(".md"):
+    for ref in remote_branches:
+        branch_slug = get_branch_slug(ref)
+
+        # Skip current branch
+        if branch_slug == current_slug:
             continue
 
-        # Get file content from git
+        # Synced folders are dot-prefixed
+        synced_dir = branches_dir / f".{branch_slug}"
+
+        # Get files from remote
         result = subprocess.run(
-            ["git", "show", f"{ref}:{file_path}"],
+            ["git", "ls-tree", "-r", "--name-only", ref, ".ragtime/branches/"],
             cwd=path,
             capture_output=True,
             text=True,
         )
 
-        if result.returncode != 0:
+        if result.returncode != 0 or not result.stdout.strip():
             continue
 
-        content = result.stdout
+        files = result.stdout.strip().split("\n")
 
-        # Determine target path (flatten to unmerged folder)
-        # Original: .claude/memory/branches/sm-feature/abc.md
-        # Target: .claude/memory/branches/sm-feature(unmerged)/abc.md
-        filename = Path(file_path).name
-        target_path = unmerged_dir / filename
+        # Clear and recreate synced folder
+        if synced_dir.exists():
+            shutil.rmtree(synced_dir)
+        synced_dir.mkdir(parents=True, exist_ok=True)
 
-        target_path.write_text(content)
-        synced += 1
+        # Extract files
+        for file_path in files:
+            if not file_path.endswith(".md"):
+                continue
 
-        # Index with pre-merge status
-        try:
-            memory = Memory.from_file(target_path)
-            memory.status = "pre-merge"
-            # Update the namespace to include (unmerged) marker
-            memory.namespace = f"branch-{branch_slug}(unmerged)"
-
-            store.db.upsert(
-                ids=[f"{memory.id}-unmerged"],
-                documents=[memory.content],
-                metadatas=[{
-                    **memory.to_metadata(),
-                    "status": "pre-merge",
-                    "source_ref": ref,
-                    "source_commit": commit_hash,
-                }],
+            content_result = subprocess.run(
+                ["git", "show", f"{ref}:{file_path}"],
+                cwd=path,
+                capture_output=True,
+                text=True,
             )
-        except Exception as e:
-            click.echo(f"  Warning: Could not index {filename}: {e}", err=True)
 
-    # Write source tracking file
-    source_file = unmerged_dir / ".source"
-    source_file.write_text(f"{ref} @ {commit_hash}\n")
+            if content_result.returncode == 0:
+                filename = Path(file_path).name
+                (synced_dir / filename).write_text(content_result.stdout)
 
-    click.echo(f"✓ Synced {synced} memories to {unmerged_dir.relative_to(path)}")
-    click.echo(f"  Source: {ref} @ {commit_hash}")
-    click.echo(f"\nSearch with: ragtime search 'query' --namespace 'branch-{branch_slug}(unmerged)'")
+        synced += 1
+        if not quiet:
+            click.echo(f"  ✓ Synced .{branch_slug}")
+
+    # Check for stale synced branches (dot-prefixed with undotted counterpart)
+    stale = []
+    if branches_dir.exists():
+        for folder in branches_dir.iterdir():
+            if folder.is_dir() and folder.name.startswith("."):
+                undotted = folder.name[1:]
+                undotted_path = branches_dir / undotted
+                if undotted_path.exists():
+                    stale.append(folder)
+
+    if stale:
+        if not quiet:
+            click.echo(f"\nStale synced branches detected:")
+            for folder in stale:
+                click.echo(f"  • {folder.name} → {folder.name[1:]} exists (merged)")
+
+        if auto_prune:
+            for folder in stale:
+                shutil.rmtree(folder)
+            if not quiet:
+                click.echo(f"\n✓ Pruned {len(stale)} stale branches")
+        elif not quiet:
+            if click.confirm("\nPrune stale branches?", default=True):
+                for folder in stale:
+                    shutil.rmtree(folder)
+                click.echo(f"✓ Pruned {len(stale)} stale branches")
+
+    if not quiet:
+        click.echo(f"\nDone. Synced {synced} branches.")
 
 
 @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 pruned without deleting")
+@click.option("--dry-run", is_flag=True, help="Show what would be pruned")
 def prune(path: Path, dry_run: bool):
-    """Remove stale (unmerged) memory folders.
+    """Remove stale synced branch folders.
 
-    Checks each (unmerged) folder and removes it if:
-    - The source branch was deleted
-    - The source branch was merged (PR closed)
-
-    Examples:
-        ragtime prune --dry-run  # See what would be pruned
-        ragtime prune            # Actually prune
+    Removes dot-prefixed folders (.branch) when an undotted
+    counterpart (branch) exists (indicating the branch was merged).
     """
     import shutil
 
     path = Path(path).resolve()
-    branches_dir = path / ".claude" / "memory" / "branches"
+    branches_dir = path / ".ragtime" / "branches"
 
     if not branches_dir.exists():
         click.echo("No branches directory found.")
         return
 
-    # Find all (unmerged) folders
-    unmerged_folders = [d for d in branches_dir.iterdir()
-                        if d.is_dir() and d.name.endswith("(unmerged)")]
+    # Find dot-prefixed folders with undotted counterparts
+    to_prune = []
+    for folder in branches_dir.iterdir():
+        if folder.is_dir() and folder.name.startswith("."):
+            undotted = folder.name[1:]
+            if (branches_dir / undotted).exists():
+                to_prune.append(folder)
 
-    if not unmerged_folders:
-        click.echo("No (unmerged) folders to prune.")
+    if not to_prune:
+        click.echo("Nothing to prune.")
         return
 
-    click.echo(f"Checking {len(unmerged_folders)} (unmerged) folders...\n")
+    click.echo("Will prune:")
+    for folder in to_prune:
+        click.echo(f"  ✗ {folder.name} → {folder.name[1:]} exists")
 
-    to_prune = []
-    to_keep = []
+    if dry_run:
+        click.echo(f"\n--dry-run: Would prune {len(to_prune)} folders")
+    else:
+        for folder in to_prune:
+            shutil.rmtree(folder)
+            click.echo(f"  Pruned: {folder.name}")
+        click.echo(f"\n✓ Pruned {len(to_prune)} folders")
 
-    for folder in unmerged_folders:
-        source_file = folder / ".source"
-        if not source_file.exists():
-            # No source tracking - mark for pruning
-            to_prune.append((folder, "no source tracking"))
-            continue
 
-        source_info = source_file.read_text().strip()
-        ref = source_info.split(" @ ")[0] if " @ " in source_info else source_info
+# ============================================================================
+# Daemon Commands
+# ============================================================================
+
 
-        # Check if ref still exists
-        result = subprocess.run(
-            ["git", "rev-parse", "--verify", ref],
-            cwd=path,
-            capture_output=True,
-            text=True,
-        )
+def get_pid_file(path: Path) -> Path:
+    """Get path to daemon PID file."""
+    return path / ".ragtime" / "daemon.pid"
 
-        if result.returncode != 0:
-            # Ref doesn't exist - check if it was merged
-            # Extract branch name from ref (e.g., origin/jm/feature -> jm/feature)
-            branch_name = ref.replace("origin/", "") if ref.startswith("origin/") else ref
 
-            # Check if a PR was merged for this branch
-            pr_result = subprocess.run(
-                ["gh", "pr", "list", "--head", branch_name, "--state", "merged", "--json", "number"],
+def get_log_file(path: Path) -> Path:
+    """Get path to daemon log file."""
+    return path / ".ragtime" / "daemon.log"
+
+
+@main.group()
+def daemon():
+    """Manage the ragtime sync daemon."""
+    pass
+
+
+@daemon.command("start")
+@click.option("--path", type=click.Path(exists=True, path_type=Path), default=".")
+@click.option("--interval", default="5m", help="Sync interval (e.g., 5m, 1h)")
+def daemon_start(path: Path, interval: str):
+    """Start the sync daemon.
+
+    Runs git fetch && ragtime sync on an interval to keep
+    remote branches synced automatically.
+    """
+    path = Path(path).resolve()
+    pid_file = get_pid_file(path)
+    log_file = get_log_file(path)
+
+    # Check if already running
+    if pid_file.exists():
+        pid = int(pid_file.read_text().strip())
+        try:
+            os.kill(pid, 0)
+            click.echo(f"Daemon already running (PID: {pid})")
+            return
+        except OSError:
+            pid_file.unlink()
+
+    # Parse interval
+    interval_seconds = 300  # default 5m
+    if interval.endswith("m"):
+        interval_seconds = int(interval[:-1]) * 60
+    elif interval.endswith("h"):
+        interval_seconds = int(interval[:-1]) * 3600
+    elif interval.endswith("s"):
+        interval_seconds = int(interval[:-1])
+    else:
+        try:
+            interval_seconds = int(interval)
+        except ValueError:
+            click.echo(f"Invalid interval: {interval}", err=True)
+            return
+
+    # Fork daemon process
+    pid = os.fork()
+    if pid > 0:
+        # Parent process
+        click.echo(f"✓ Daemon started (PID: {pid})")
+        click.echo(f"  Interval: {interval}")
+        click.echo(f"  Log: {log_file.relative_to(path)}")
+        click.echo(f"\nStop with: ragtime daemon stop")
+        return
+
+    # Child process - become daemon
+    os.setsid()
+
+    # Write PID file
+    pid_file.write_text(str(os.getpid()))
+
+    # Redirect output to log file
+    log_fd = open(log_file, "a")
+    os.dup2(log_fd.fileno(), sys.stdout.fileno())
+    os.dup2(log_fd.fileno(), sys.stderr.fileno())
+
+    import time
+    from datetime import datetime
+
+    print(f"\n[{datetime.now().isoformat()}] Daemon started (interval: {interval})")
+
+    while True:
+        try:
+            print(f"[{datetime.now().isoformat()}] Running sync...")
+
+            # Fetch
+            subprocess.run(
+                ["git", "fetch", "--quiet"],
                 cwd=path,
                 capture_output=True,
-                text=True,
             )
 
-            if pr_result.returncode == 0 and pr_result.stdout.strip() != "[]":
-                to_prune.append((folder, f"PR merged for {branch_name}"))
-            else:
-                to_prune.append((folder, f"branch deleted: {ref}"))
-        else:
-            to_keep.append((folder, ref))
+            # Sync
+            subprocess.run(
+                ["ragtime", "sync", "--quiet", "--auto-prune"],
+                cwd=path,
+                capture_output=True,
+            )
 
-    # Report findings
-    if to_prune:
-        click.echo("Will prune:")
-        for folder, reason in to_prune:
-            click.echo(f"  ✗ {folder.name} ({reason})")
+            print(f"[{datetime.now().isoformat()}] Sync complete")
 
-    if to_keep:
-        click.echo("\nKeeping (branch still active):")
-        for folder, ref in to_keep:
-            click.echo(f"  ✓ {folder.name}")
+        except Exception as e:
+            print(f"[{datetime.now().isoformat()}] Error: {e}")
 
-    if not to_prune:
-        click.echo("\nNothing to prune.")
+        time.sleep(interval_seconds)
+
+
+@daemon.command("stop")
+@click.option("--path", type=click.Path(exists=True, path_type=Path), default=".")
+def daemon_stop(path: Path):
+    """Stop the sync daemon."""
+    path = Path(path).resolve()
+    pid_file = get_pid_file(path)
+
+    if not pid_file.exists():
+        click.echo("Daemon not running.")
         return
 
-    # Actually prune if not dry-run
-    if dry_run:
-        click.echo(f"\n--dry-run: Would prune {len(to_prune)} folders")
-    else:
-        click.echo("")
-        db = get_db(path)
-
-        for folder, reason in to_prune:
-            # Remove from index
-            branch_slug = folder.name.replace("(unmerged)", "")
-            # Find and delete indexed memories for this folder
-            results = db.collection.get(
-                where={"namespace": f"branch-{folder.name}"}
-            )
-            if results["ids"]:
-                db.delete(results["ids"])
+    pid = int(pid_file.read_text().strip())
 
-            # Remove folder
-            shutil.rmtree(folder)
-            click.echo(f"  Pruned: {folder.name}")
+    try:
+        os.kill(pid, signal.SIGTERM)
+        pid_file.unlink()
+        click.echo(f"✓ Daemon stopped (PID: {pid})")
+    except OSError:
+        pid_file.unlink()
+        click.echo("Daemon was not running (stale PID file removed).")
 
-        click.echo(f"\n✓ Pruned {len(to_prune)} folders")
+
+@daemon.command("status")
+@click.option("--path", type=click.Path(exists=True, path_type=Path), default=".")
+def daemon_status(path: Path):
+    """Check daemon status."""
+    path = Path(path).resolve()
+    pid_file = get_pid_file(path)
+    log_file = get_log_file(path)
+
+    if not pid_file.exists():
+        click.echo("Daemon: not running")
+        return
+
+    pid = int(pid_file.read_text().strip())
+
+    try:
+        os.kill(pid, 0)
+        click.echo(f"Daemon: running (PID: {pid})")
+
+        # Show last few log lines
+        if log_file.exists():
+            lines = log_file.read_text().strip().split("\n")
+            if lines:
+                click.echo(f"\nRecent log:")
+                for line in lines[-5:]:
+                    click.echo(f"  {line}")
+    except OSError:
+        click.echo("Daemon: not running (stale PID file)")
+        pid_file.unlink()
+
+
+@main.command()
+@click.option("--check", is_flag=True, help="Only check for updates, don't install")
+def update(check: bool):
+    """Check for and install ragtime updates."""
+    import json
+    from urllib.request import urlopen
+    from urllib.error import URLError
+
+    current = "0.2.1"
+
+    click.echo(f"Current version: {current}")
+    click.echo("Checking PyPI for updates...")
+
+    try:
+        with urlopen("https://pypi.org/pypi/ragtime-cli/json", timeout=10) as resp:
+            data = json.loads(resp.read().decode())
+            latest = data["info"]["version"]
+    except (URLError, json.JSONDecodeError, KeyError) as e:
+        click.echo(f"✗ Could not check for updates: {e}", err=True)
+        return
+
+    # Compare versions
+    def parse_version(v):
+        return tuple(int(x) for x in v.split("."))
+
+    current_v = parse_version(current)
+    latest_v = parse_version(latest)
+
+    if latest_v > current_v:
+        click.echo(f"✓ New version available: {latest}")
+
+        if check:
+            click.echo(f"\nUpdate with: pip install --upgrade ragtime-cli")
+            return
+
+        if click.confirm(f"\nInstall {latest}?", default=True):
+            result = subprocess.run(
+                [sys.executable, "-m", "pip", "install", "--upgrade", "ragtime-cli"],
+                capture_output=False,
+            )
+            if result.returncode == 0:
+                click.echo(f"\n✓ Updated to {latest}")
+                click.echo("  Restart your shell to use the new version")
+            else:
+                click.echo(f"\n✗ Update failed", err=True)
+    elif latest_v < current_v:
+        click.echo(f"✓ You're ahead of PyPI ({current} > {latest})")
+    else:
+        click.echo(f"✓ You're on the latest version ({current})")
 
 
 if __name__ == "__main__":

{ragtime_cli-0.1.2 → ragtime_cli-0.2.1}/src/config.py

@@ -12,12 +12,13 @@ import yaml
 @dataclass
 class DocsConfig:
     """Configuration for docs indexing."""
-    paths: list[str] = field(default_factory=lambda: ["docs", ".claude/memory"])
+    paths: list[str] = field(default_factory=lambda: ["docs", ".ragtime"])
     patterns: list[str] = field(default_factory=lambda: ["**/*.md"])
     exclude: list[str] = field(default_factory=lambda: [
         "**/node_modules/**",
         "**/.git/**",
-        "**/.ragtime/**",
+        "**/.ragtime/index/**",
+        "**/.ragtime/branches/.*",  # Exclude synced (dot-prefixed) branches
     ])
 
 

{ragtime_cli-0.1.2 → ragtime_cli-0.2.1}/src/memory.py

@@ -1,7 +1,7 @@
 """
 Memory storage for ragtime.
 
-Handles structured memory storage in .claude/memory/ directory.
+Handles structured memory storage in .ragtime/ directory.
 Each memory is a markdown file with YAML frontmatter.
 """
 
@@ -153,7 +153,7 @@ class MemoryStore:
             db: RagtimeDB instance for vector search
         """
         self.project_path = project_path
-        self.memory_dir = project_path / ".claude" / "memory"
+        self.memory_dir = project_path / ".ragtime"
         self.db = db
 
     def save(self, memory: Memory) -> Path:
@@ -348,7 +348,7 @@ class MemoryStore:
         """
         Reindex all memory files.
 
-        Scans .claude/memory/ and indexes any files not in ChromaDB.
+        Scans .ragtime/ and indexes any files not in ChromaDB.
         Returns count of files indexed.
         """
         if not self.memory_dir.exists():