ragtime-cli 0.2.4__py3-none-any.whl → 0.2.6__py3-none-any.whl

{ragtime_cli-0.2.4.dist-info → ragtime_cli-0.2.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ragtime-cli
-Version: 0.2.4
+Version: 0.2.6
 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
@@ -35,7 +35,8 @@ Local-first memory and RAG system for Claude Code. Semantic search over code, do
 ## Features
 
 - **Memory Storage**: Store structured knowledge with namespaces, types, and metadata
-- **Semantic Search**: Query memories and docs with natural language
+- **Semantic Search**: Query memories, docs, and code with natural language
+- **Code Indexing**: Index functions, classes, and composables from Python, TypeScript, Vue, and Dart
 - **Cross-Branch Sync**: Share context with teammates before PRs merge
 - **Convention Checking**: Verify code follows team standards before PRs
 - **Doc Generation**: Generate documentation from code (stubs or AI-powered)
@@ -96,11 +97,26 @@ ragtime forget <memory-id>
 ### Search & Indexing
 
 ```bash
-# Index docs
+# Index everything (docs + code)
+ragtime index
+
+# Index only docs
 ragtime index --type docs
 
-# Semantic search
-ragtime search "how does auth work" --namespace app --limit 10
+# Index only code (functions, classes, composables)
+ragtime index --type code
+
+# Re-index with clear (removes old entries)
+ragtime index --clear
+
+# Semantic search across all content
+ragtime search "how does auth work" --limit 10
+
+# Search only code
+ragtime search "useAsyncState" --type code
+
+# Search only docs
+ragtime search "authentication" --type docs --namespace app
 
 # Reindex memory files
 ragtime reindex
@@ -220,13 +236,42 @@ docs:
 
 code:
   paths: ["."]
-  languages: ["python", "typescript", "dart"]
+  languages: ["python", "typescript", "javascript", "vue", "dart"]
+  exclude: ["**/node_modules/**", "**/build/**", "**/dist/**"]
 
 conventions:
   files: [".ragtime/CONVENTIONS.md"]
   also_search_memories: true
 ```
 
+## Code Indexing
+
+The code indexer extracts meaningful symbols from your codebase:
+
+| Language | What Gets Indexed |
+|----------|-------------------|
+| Python | Classes, methods, functions (with docstrings) |
+| TypeScript/JS | Exported functions, classes, interfaces, types, constants |
+| Vue | Components, composable usage (useXxx calls) |
+| Dart | Classes, functions, mixins, extensions |
+
+Each symbol is indexed with:
+- **content**: The code snippet with signature and docstring
+- **file**: Full path to the source file
+- **line**: Line number for quick navigation
+- **symbol_name**: Searchable name (e.g., `useAsyncState`, `JWTManager.validate`)
+- **symbol_type**: `function`, `class`, `method`, `interface`, `composable`, etc.
+
+Example search results:
+```
+ragtime search "useAsyncState" --type code
+
+[1] /apps/web/components/agency/payers.vue
+    Type: code | Symbol: payers:useAsyncState
+    Score: 0.892
+    Uses composable: useAsyncState...
+```
+
 ## Memory Format
 
 Memories are markdown files with YAML frontmatter:

{ragtime_cli-0.2.4.dist-info → ragtime_cli-0.2.6.dist-info}/RECORD

@@ -1,10 +1,10 @@
-ragtime_cli-0.2.4.dist-info/licenses/LICENSE,sha256=9A0wJs2PRDciGRH4F8JUJ-aMKYQyq_gVu2ixrXs-l5A,1070
+ragtime_cli-0.2.6.dist-info/licenses/LICENSE,sha256=9A0wJs2PRDciGRH4F8JUJ-aMKYQyq_gVu2ixrXs-l5A,1070
 src/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-src/cli.py,sha256=iNCYKD6w1gi64eNeb8BFj-xPzVnQLqHMzmPzoRGE3tI,67135
-src/config.py,sha256=kaJV-7yI-LMW16e1w6JvM1ZCjgPf8EiBBOM4OXio6I8,4045
+src/cli.py,sha256=Hnf2cRcI-czCBV7CGyGMOUTI_ZqxuA8ZDK9R_msw540,70299
+src/config.py,sha256=mlqRkq1gi_bINqqz6TqT4GAR0M0G_hyeo7oY2zr-xsE,4066
 src/db.py,sha256=BKrlhilXYHNaj-ZcffinSXVhdUqowmwpFPBx7aLxamU,4642
-src/mcp_server.py,sha256=Tx0i73GXO0YmcVrdO7UjRMS0auN8fBG2LOpHuf_LUC0,20374
-src/memory.py,sha256=POT2lYeBcEx4_MPbsIdet6ScwcjmuETz8Dxmz-Z_7IY,11939
+src/mcp_server.py,sha256=uOixURyPK0sodt3OqZJJBlUHncas9PPC49N-OGGuSAg,20374
+src/memory.py,sha256=8kuHBLDTsZdSBumgA9FRJhHp_VNeoV78QFmiDcJs7YI,12033
 src/commands/audit.md,sha256=Xkucm-gfBIMalK9wf7NBbyejpsqBTUAGGlb7GxMtMPY,5137
 src/commands/create-pr.md,sha256=u6-jVkDP_6bJQp6ImK039eY9F6B9E2KlAVlvLY-WV6Q,9483
 src/commands/generate-docs.md,sha256=9W2Yy-PDyC3p5k39uEb31z5YAHkSKsQLg6gV3tLgSnQ,7015
@@ -15,10 +15,11 @@ src/commands/recall.md,sha256=unQPWsmocKRoQR7jRtjrj8aVcMHverjGR6u5mYL8TLw,6008
 src/commands/remember.md,sha256=nNewsUhIqF4wtD1jhVDZvmLZjdcmPN6NmUM43SdWepc,5368
 src/commands/save.md,sha256=7gTpW46AU9Y4l8XVZ8f4h1sEdBfVqIRA7hlidUxMAC4,251
 src/commands/start.md,sha256=qoqhkMgET74DBx8YPIT1-wqCiVBUDxlmevigsCinHSY,6506
-src/indexers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+src/indexers/__init__.py,sha256=MYoCPZUpHakMX1s2vWnc9shjWfx_X1_0JzUhpKhnKUQ,454
+src/indexers/code.py,sha256=f-D6NLgayPbD-8goVKI-vlsiHgyrzS8Mkmo1oRFrBII,16473
 src/indexers/docs.py,sha256=7FENHaKSvC1T557bRzvmrjyaG_vK94GuQG9XMZdr89w,3349
-ragtime_cli-0.2.4.dist-info/METADATA,sha256=VtuTNejyKDZqNrVuC5tJGNHWDHVrIY-2Pk1-k0NlwWY,8383
-ragtime_cli-0.2.4.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-ragtime_cli-0.2.4.dist-info/entry_points.txt,sha256=cWLbeyMxZNbew-THS3bHXTpCRXt1EaUy5QUOXGXLjl4,75
-ragtime_cli-0.2.4.dist-info/top_level.txt,sha256=74rtVfumQlgAPzR5_2CgYN24MB0XARCg0t-gzk6gTrM,4
-ragtime_cli-0.2.4.dist-info/RECORD,,
+ragtime_cli-0.2.6.dist-info/METADATA,sha256=fBoyzYYbWaK5RgBU_VGUXAxxhWIsQXozRIMTsFKjbBQ,9875
+ragtime_cli-0.2.6.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+ragtime_cli-0.2.6.dist-info/entry_points.txt,sha256=cWLbeyMxZNbew-THS3bHXTpCRXt1EaUy5QUOXGXLjl4,75
+ragtime_cli-0.2.6.dist-info/top_level.txt,sha256=74rtVfumQlgAPzR5_2CgYN24MB0XARCg0t-gzk6gTrM,4
+ragtime_cli-0.2.6.dist-info/RECORD,,

src/cli.py

@@ -11,7 +11,10 @@ import sys
 
 from .db import RagtimeDB
 from .config import RagtimeConfig, init_config
-from .indexers.docs import index_directory as index_docs
+from .indexers import (
+    discover_docs, index_doc_file, DocEntry,
+    discover_code_files, index_code_file, CodeEntry,
+)
 from .memory import Memory, MemoryStore
 
 
@@ -166,7 +169,7 @@ def get_remote_branches_with_ragtime(path: Path) -> list[str]:
 
 
 @click.group()
-@click.version_option(version="0.2.4")
+@click.version_option(version="0.2.6")
 def main():
     """Ragtime - semantic search over code and documentation."""
     pass
@@ -273,34 +276,98 @@ def index(path: Path, index_type: str, clear: bool):
             db.clear(type_filter=index_type)
 
     if index_type in ("all", "docs"):
-        total_entries = []
+        # Discover all doc files first
+        all_doc_files = []
         for docs_path in config.docs.paths:
             docs_root = path / docs_path
             if not docs_root.exists():
                 click.echo(f"  Docs path {docs_root} not found, skipping...")
                 continue
-            click.echo(f"Indexing docs in {docs_root}...")
-            entries = index_docs(
+            files = discover_docs(
                 docs_root,
                 patterns=config.docs.patterns,
                 exclude=config.docs.exclude,
             )
-            total_entries.extend(entries)
-
-        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")
+            all_doc_files.extend(files)
+
+        if all_doc_files:
+            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")
         else:
             click.echo("  No documents found")
 
     if index_type in ("all", "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}/**")
-        click.echo("Code indexing not yet implemented")
+
+        # Discover all code files first
+        all_code_files = []
+        for code_path_str in config.code.paths:
+            code_root = path / code_path_str
+            if not code_root.exists():
+                click.echo(f"  Code path {code_root} not found, skipping...")
+                continue
+            files = discover_code_files(
+                code_root,
+                languages=config.code.languages,
+                exclude=code_exclude,
+            )
+            all_code_files.extend(files)
+
+        if all_code_files:
+            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
+                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")
+        else:
+            click.echo("  No code files found")
 
     stats = db.stats()
     click.echo(f"\nIndex stats: {stats['total']} total ({stats['docs']} docs, {stats['code']} code)")
@@ -1041,7 +1108,15 @@ def daemon_start(path: Path, interval: str):
 
     Runs git fetch && ragtime sync on an interval to keep
     remote branches synced automatically.
+
+    Note: This command requires Unix (Linux/macOS). On Windows, use Task Scheduler instead.
     """
+    # Check for Windows - os.fork() is Unix-only
+    if sys.platform == "win32":
+        click.echo("✗ Daemon mode is not supported on Windows.", err=True)
+        click.echo("  Use Windows Task Scheduler to run 'ragtime sync' periodically instead.")
+        return
+
     path = Path(path).resolve()
     pid_file = get_pid_file(path)
     log_file = get_log_file(path)
@@ -1088,6 +1163,7 @@ 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())
@@ -1652,7 +1728,7 @@ def get_function_params(node) -> list:
         if arg.annotation:
             try:
                 type_hint = ast.unparse(arg.annotation)
-            except:
+            except Exception:
                 type_hint = "Any"
 
         default = "-"
@@ -1660,7 +1736,7 @@ def get_function_params(node) -> list:
         if default_idx >= 0 and default_idx < len(defaults):
             try:
                 default = f"`{ast.unparse(defaults[default_idx])}`"
-            except:
+            except Exception:
                 default = "..."
 
         params.append({
@@ -1679,7 +1755,7 @@ def get_return_annotation(node) -> str:
     if node.returns:
         try:
             return ast.unparse(node.returns)
-        except:
+        except Exception:
             return "Any"
     return "None"
 
@@ -1803,7 +1879,7 @@ def audit(docs_path: Path, path: Path, fix: bool, as_json: bool):
                 parts = content.split("---", 2)
                 if len(parts) >= 3:
                     existing_meta = yaml.safe_load(parts[1]) or {}
-            except:
+            except Exception:
                 pass
 
         # Analyze file for suggestions
@@ -1950,7 +2026,7 @@ def update(check: bool):
     from urllib.request import urlopen
     from urllib.error import URLError
 
-    current = "0.2.4"
+    current = "0.2.6"
 
     click.echo(f"Current version: {current}")
     click.echo("Checking PyPI for updates...")

src/config.py

@@ -26,7 +26,7 @@ class DocsConfig:
 class CodeConfig:
     """Configuration for code indexing."""
     paths: list[str] = field(default_factory=lambda: ["."])
-    languages: list[str] = field(default_factory=lambda: ["dart", "typescript", "python"])
+    languages: list[str] = field(default_factory=lambda: ["python", "typescript", "javascript", "vue", "dart"])
     exclude: list[str] = field(default_factory=lambda: [
         "**/node_modules/**",
         "**/.git/**",

src/indexers/__init__.py

@@ -0,0 +1,11 @@
+"""Indexers for ragtime - parse different content types for vector search."""
+
+from .docs import index_directory as index_docs, DocEntry, discover_docs, index_file as index_doc_file
+from .code import index_directory as index_code, CodeEntry, discover_code_files, index_file as index_code_file
+
+__all__ = [
+    "index_docs", "index_code",
+    "DocEntry", "CodeEntry",
+    "discover_docs", "discover_code_files",
+    "index_doc_file", "index_code_file",
+]

src/indexers/code.py

@@ -0,0 +1,473 @@
+"""
+Code indexer - extracts functions, classes, and types from source files.
+
+Parses code to create searchable chunks for each meaningful unit (function, class, etc).
+This allows searching for specific code constructs like "useAsyncState" or "JWTManager".
+"""
+
+import ast
+import re
+from fnmatch import fnmatch
+from pathlib import Path
+from dataclasses import dataclass
+
+
+# Language file extensions
+LANGUAGE_EXTENSIONS = {
+    "python": [".py"],
+    "typescript": [".ts", ".tsx"],
+    "javascript": [".js", ".jsx"],
+    "vue": [".vue"],
+    "dart": [".dart"],
+}
+
+
+@dataclass
+class CodeEntry:
+    """A parsed code symbol ready for indexing."""
+    content: str           # The actual code + context
+    file_path: str         # Full path to file
+    language: str          # python, typescript, etc.
+    symbol_name: str       # Function/class/component name
+    symbol_type: str       # function, class, interface, component, etc.
+    line_number: int       # Line where symbol starts
+    docstring: str | None = None  # Extracted docstring/JSDoc
+
+    def to_metadata(self) -> dict:
+        """Convert to ChromaDB metadata dict."""
+        return {
+            "type": "code",
+            "file": self.file_path,
+            "language": self.language,
+            "symbol_name": self.symbol_name,
+            "symbol_type": self.symbol_type,
+            "line": self.line_number,
+        }
+
+
+def get_extensions_for_languages(languages: list[str]) -> list[str]:
+    """Get file extensions for the specified languages."""
+    extensions = []
+    for lang in languages:
+        extensions.extend(LANGUAGE_EXTENSIONS.get(lang, []))
+    return extensions
+
+
+def discover_code_files(
+    root: Path,
+    languages: list[str],
+    exclude: list[str] | None = None,
+) -> list[Path]:
+    """
+    Find all code files to index.
+
+    Args:
+        root: Directory to search
+        languages: List of languages to include
+        exclude: Patterns to exclude
+    """
+    exclude = exclude or [
+        "**/node_modules/**",
+        "**/.git/**",
+        "**/build/**",
+        "**/dist/**",
+        "**/__pycache__/**",
+        "**/.venv/**",
+        "**/venv/**",
+        "**/.dart_tool/**",
+    ]
+
+    extensions = get_extensions_for_languages(languages)
+    files = []
+
+    for ext in extensions:
+        for path in root.rglob(f"*{ext}"):
+            if path.is_file():
+                # Check exclusions using proper glob matching
+                skip = False
+                # Use relative path for matching to avoid absolute path issues
+                try:
+                    rel_path = str(path.relative_to(root))
+                except ValueError:
+                    rel_path = str(path)
+
+                for ex in exclude:
+                    # Handle ** patterns by checking if pattern appears in path
+                    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
+                    elif fnmatch(rel_path, ex) or fnmatch(path.name, ex):
+                        skip = True
+                        break
+                if not skip:
+                    files.append(path)
+
+    return files
+
+
+def index_python_file(file_path: Path, content: str) -> list[CodeEntry]:
+    """Extract code entries from a Python file."""
+    entries = []
+
+    try:
+        tree = ast.parse(content)
+    except SyntaxError:
+        return entries
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.ClassDef):
+            # Get class code (signature + docstring + method signatures)
+            start_line = node.lineno
+            docstring = ast.get_docstring(node) or ""
+
+            # Build a summary of the class
+            method_names = []
+            for item in node.body:
+                if isinstance(item, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                    method_names.append(item.name)
+
+            class_summary = f"class {node.name}:\n"
+            if docstring:
+                class_summary += f'    """{docstring}"""\n'
+            if method_names:
+                class_summary += f"\n    # Methods: {', '.join(method_names)}\n"
+
+            entries.append(CodeEntry(
+                content=class_summary,
+                file_path=str(file_path),
+                language="python",
+                symbol_name=node.name,
+                symbol_type="class",
+                line_number=start_line,
+                docstring=docstring,
+            ))
+
+            # Also index public methods
+            for item in node.body:
+                if isinstance(item, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                    if item.name.startswith("_") and item.name != "__init__":
+                        continue
+
+                    method_doc = ast.get_docstring(item) or ""
+                    async_prefix = "async " if isinstance(item, ast.AsyncFunctionDef) else ""
+
+                    # Get signature
+                    args = []
+                    for arg in item.args.args:
+                        if arg.arg == "self":
+                            continue
+                        type_hint = ""
+                        if arg.annotation:
+                            try:
+                                type_hint = f": {ast.unparse(arg.annotation)}"
+                            except Exception:
+                                pass
+                        args.append(f"{arg.arg}{type_hint}")
+
+                    ret_type = ""
+                    if item.returns:
+                        try:
+                            ret_type = f" -> {ast.unparse(item.returns)}"
+                        except Exception:
+                            pass
+
+                    method_sig = f"{async_prefix}def {item.name}({', '.join(args)}){ret_type}"
+                    method_content = f"class {node.name}:\n    {method_sig}:\n"
+                    if method_doc:
+                        method_content += f'        """{method_doc}"""\n'
+
+                    entries.append(CodeEntry(
+                        content=method_content,
+                        file_path=str(file_path),
+                        language="python",
+                        symbol_name=f"{node.name}.{item.name}",
+                        symbol_type="method",
+                        line_number=item.lineno,
+                        docstring=method_doc,
+                    ))
+
+        elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            # Top-level function
+            if hasattr(node, 'col_offset') and node.col_offset > 0:
+                continue  # Skip nested functions
+
+            docstring = ast.get_docstring(node) or ""
+            async_prefix = "async " if isinstance(node, ast.AsyncFunctionDef) else ""
+
+            # Get signature
+            args = []
+            for arg in node.args.args:
+                type_hint = ""
+                if arg.annotation:
+                    try:
+                        type_hint = f": {ast.unparse(arg.annotation)}"
+                    except Exception:
+                        pass
+                args.append(f"{arg.arg}{type_hint}")
+
+            ret_type = ""
+            if node.returns:
+                try:
+                    ret_type = f" -> {ast.unparse(node.returns)}"
+                except Exception:
+                    pass
+
+            func_sig = f"{async_prefix}def {node.name}({', '.join(args)}){ret_type}"
+            func_content = f"{func_sig}:\n"
+            if docstring:
+                func_content += f'    """{docstring}"""\n'
+
+            entries.append(CodeEntry(
+                content=func_content,
+                file_path=str(file_path),
+                language="python",
+                symbol_name=node.name,
+                symbol_type="function",
+                line_number=node.lineno,
+                docstring=docstring,
+            ))
+
+    return entries
+
+
+def index_typescript_file(file_path: Path, content: str) -> list[CodeEntry]:
+    """Extract code entries from a TypeScript/JavaScript file."""
+    entries = []
+    lines = content.split("\n")
+
+    # Patterns for different constructs
+    patterns = [
+        # Exported functions
+        (r'export\s+(?:default\s+)?(?:async\s+)?function\s+(\w+)\s*(?:<[^>]+>)?\s*\(([^)]*)\)(?:\s*:\s*([^\{]+))?',
+         "function"),
+        # Arrow function exports
+        (r'export\s+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"),
+        # Interface exports
+        (r'export\s+(?:default\s+)?interface\s+(\w+)(?:<[^>]+>)?(?:\s+extends\s+([^{]+))?',
+         "interface"),
+        # Type exports
+        (r'export\s+type\s+(\w+)(?:<[^>]+>)?\s*=',
+         "type"),
+        # Const exports (useful for config objects, composables, etc.)
+        (r'export\s+const\s+(\w+)\s*(?::\s*([^=]+))?\s*=\s*(?!.*=>)',
+         "constant"),
+    ]
+
+    for i, line in enumerate(lines):
+        for pattern, symbol_type in patterns:
+            match = re.match(pattern, line.strip())
+            if match:
+                symbol_name = match.group(1)
+
+                # Get context (a few lines around the definition)
+                start = max(0, i - 1)
+                end = min(len(lines), i + 10)
+                context_lines = lines[start:end]
+
+                # Extract JSDoc if present
+                jsdoc = ""
+                if i > 0 and lines[i - 1].strip().endswith("*/"):
+                    # Look backward for JSDoc start
+                    for j in range(i - 1, max(0, i - 20), -1):
+                        if "/**" in lines[j]:
+                            jsdoc_lines = lines[j:i]
+                            jsdoc = "\n".join(jsdoc_lines)
+                            break
+
+                entries.append(CodeEntry(
+                    content="\n".join(context_lines),
+                    file_path=str(file_path),
+                    language="typescript" if file_path.suffix in [".ts", ".tsx"] else "javascript",
+                    symbol_name=symbol_name,
+                    symbol_type=symbol_type,
+                    line_number=i + 1,
+                    docstring=jsdoc if jsdoc else None,
+                ))
+                break
+
+    # Also look for Vue composables pattern (useXxx functions)
+    composable_pattern = r'(?:export\s+)?(?:const|function)\s+(use[A-Z]\w*)'
+    for i, line in enumerate(lines):
+        match = re.search(composable_pattern, line)
+        if match:
+            symbol_name = match.group(1)
+            # Check if we already indexed this
+            if not any(e.symbol_name == symbol_name for e in entries):
+                start = max(0, i - 1)
+                end = min(len(lines), i + 15)
+
+                entries.append(CodeEntry(
+                    content="\n".join(lines[start:end]),
+                    file_path=str(file_path),
+                    language="typescript" if file_path.suffix in [".ts", ".tsx"] else "javascript",
+                    symbol_name=symbol_name,
+                    symbol_type="composable",
+                    line_number=i + 1,
+                ))
+
+    return entries
+
+
+def index_vue_file(file_path: Path, content: str) -> list[CodeEntry]:
+    """Extract code entries from a Vue SFC file."""
+    entries = []
+
+    # Get component name from filename
+    component_name = file_path.stem
+
+    # Extract script section
+    script_match = re.search(
+        r'<script[^>]*(?:setup)?[^>]*>(.*?)</script>',
+        content,
+        re.DOTALL | re.IGNORECASE
+    )
+
+    script_content = script_match.group(1) if script_match else ""
+
+    # Add the component itself
+    entries.append(CodeEntry(
+        content=f"Vue Component: {component_name}\n\n{script_content[:500]}",
+        file_path=str(file_path),
+        language="vue",
+        symbol_name=component_name,
+        symbol_type="component",
+        line_number=1,
+    ))
+
+    # If there's script content, parse it for composables and functions
+    if script_content:
+        # Look for composable usage (useXxx calls)
+        composable_usages = re.findall(r'(use[A-Z]\w*)\s*\(', script_content)
+        for composable in set(composable_usages):
+            # Find the line
+            for i, line in enumerate(content.split("\n")):
+                if composable in line:
+                    entries.append(CodeEntry(
+                        content=f"Uses composable: {composable}\n{line.strip()}",
+                        file_path=str(file_path),
+                        language="vue",
+                        symbol_name=f"{component_name}:{composable}",
+                        symbol_type="composable_usage",
+                        line_number=i + 1,
+                    ))
+                    break
+
+        # Parse script for functions
+        ts_entries = index_typescript_file(file_path, script_content)
+        for entry in ts_entries:
+            entry.language = "vue"
+            entry.symbol_name = f"{component_name}.{entry.symbol_name}"
+            entries.append(entry)
+
+    return entries
+
+
+def index_dart_file(file_path: Path, content: str) -> list[CodeEntry]:
+    """Extract code entries from a Dart file."""
+    entries = []
+    lines = content.split("\n")
+
+    # Patterns for Dart constructs
+    patterns = [
+        # 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*\(',
+         "function"),
+        # Mixins
+        (r'mixin\s+(\w+)(?:\s+on\s+(\w+))?',
+         "mixin"),
+        # Extensions
+        (r'extension\s+(\w+)\s+on\s+(\w+)',
+         "extension"),
+    ]
+
+    for i, line in enumerate(lines):
+        for pattern, symbol_type in patterns:
+            match = re.match(r'\s*' + pattern, line)
+            if match:
+                symbol_name = match.group(1)
+
+                # Get context
+                start = max(0, i - 1)
+                end = min(len(lines), i + 10)
+
+                # Extract doc comment if present
+                doc_comment = ""
+                if i > 0:
+                    for j in range(i - 1, max(0, i - 20), -1):
+                        if lines[j].strip().startswith("///"):
+                            doc_comment = lines[j].strip() + "\n" + doc_comment
+                        elif lines[j].strip():
+                            break
+
+                entries.append(CodeEntry(
+                    content="\n".join(lines[start:end]),
+                    file_path=str(file_path),
+                    language="dart",
+                    symbol_name=symbol_name,
+                    symbol_type=symbol_type,
+                    line_number=i + 1,
+                    docstring=doc_comment if doc_comment else None,
+                ))
+                break
+
+    return entries
+
+
+def index_file(file_path: Path) -> list[CodeEntry]:
+    """
+    Parse a single code file into CodeEntry objects.
+
+    Returns empty list if file can't be parsed.
+    """
+    try:
+        content = file_path.read_text(encoding='utf-8')
+    except (IOError, UnicodeDecodeError):
+        return []
+
+    # Skip empty files
+    if not content.strip():
+        return []
+
+    suffix = file_path.suffix.lower()
+
+    if suffix == ".py":
+        return index_python_file(file_path, content)
+    elif suffix in [".ts", ".tsx", ".js", ".jsx"]:
+        return index_typescript_file(file_path, content)
+    elif suffix == ".vue":
+        return index_vue_file(file_path, content)
+    elif suffix == ".dart":
+        return index_dart_file(file_path, content)
+
+    return []
+
+
+def index_directory(
+    root: Path,
+    languages: list[str],
+    exclude: list[str] | None = None,
+) -> list[CodeEntry]:
+    """
+    Index all code files in a directory.
+
+    Returns list of CodeEntry objects ready for vector DB.
+    """
+    files = discover_code_files(root, languages, exclude)
+    entries = []
+
+    for file_path in files:
+        file_entries = index_file(file_path)
+        entries.extend(file_entries)
+
+    return entries

src/mcp_server.py

@@ -487,7 +487,7 @@ class RagtimeMCPServer:
                         "protocolVersion": "2024-11-05",
                         "serverInfo": {
                             "name": "ragtime",
-                            "version": "0.1.0",
+                            "version": "0.2.6",
                         },
                         "capabilities": {
                             "tools": {},

src/memory.py

@@ -191,7 +191,12 @@ class MemoryStore:
             return None
 
         metadata = results["metadatas"][0]
-        file_path = self.memory_dir / metadata.get("file", "")
+        file_rel_path = metadata.get("file", "")
+
+        if not file_rel_path:
+            return None
+
+        file_path = self.memory_dir / file_rel_path
 
         if file_path.exists():
             return Memory.from_file(file_path)