codetree-rag 0.1.0__py3-none-any.whl

codetree/__init__.py

@@ -0,0 +1,13 @@
+"""
+CodeTree - Vectorless RAG for Code Repositories
+
+Navigate your codebase like a human expert using LLM reasoning.
+"""
+
+from .core import CodeTree
+from .indexer import CodeIndexer
+from .retriever import CodeRetriever
+from .config import Config
+
+__version__ = "0.1.0"
+__all__ = ["CodeTree", "CodeIndexer", "CodeRetriever", "Config"]

codetree/cli.py

@@ -0,0 +1,220 @@
+"""Command-line interface for CodeTree."""
+
+import sys
+from pathlib import Path
+
+import click
+from rich.console import Console
+from rich.panel import Panel
+from rich.syntax import Syntax
+from rich.tree import Tree as RichTree
+
+from .core import CodeTree
+from .config import Config
+
+console = Console()
+
+
+@click.group()
+@click.version_option(version="0.1.0")
+def main():
+    """🌲 CodeTree - Vectorless RAG for Code Repositories"""
+    pass
+
+
+@main.command()
+@click.argument("repo_path", type=click.Path(exists=True), default=".")
+@click.option("--output", "-o", type=click.Path(), help="Output path for index JSON")
+def index(repo_path: str, output: str | None):
+    """Build an index for a code repository."""
+    repo_path = Path(repo_path).resolve()
+    
+    console.print(f"\n🌲 [bold]CodeTree[/bold] - Indexing repository...")
+    console.print(f"   Path: [cyan]{repo_path}[/cyan]\n")
+    
+    with console.status("[bold green]Parsing code..."):
+        tree = CodeTree(repo_path)
+        index = tree.build_index(save=(output is None))
+    
+    # Print stats
+    console.print(Panel.fit(
+        f"[green]✓[/green] Indexed [bold]{index.total_files}[/bold] files\n"
+        f"[green]✓[/green] [bold]{index.total_lines:,}[/bold] total lines\n"
+        f"[green]✓[/green] Languages: {', '.join(index.languages.keys())}",
+        title="Index Complete",
+        border_style="green",
+    ))
+    
+    if output:
+        output_path = Path(output)
+        tree.indexer.save_index(index, output_path)
+        console.print(f"\n📁 Index saved to: [cyan]{output_path}[/cyan]")
+    else:
+        console.print(f"\n📁 Index saved to: [cyan]{repo_path / '.codetree' / 'index.json'}[/cyan]")
+
+
+@main.command()
+@click.argument("question")
+@click.option("--repo", "-r", type=click.Path(exists=True), default=".", help="Repository path")
+def query(question: str, repo: str):
+    """Query the codebase with a natural language question."""
+    repo_path = Path(repo).resolve()
+    
+    tree = CodeTree(repo_path)
+    
+    if tree.index is None:
+        console.print("[yellow]No index found. Building index first...[/yellow]\n")
+        with console.status("[bold green]Indexing..."):
+            tree.build_index()
+    
+    console.print(f"\n🔍 [bold]Question:[/bold] {question}\n")
+    
+    with console.status("[bold green]Thinking..."):
+        answer = tree.query(question)
+    
+    console.print(Panel(answer, title="Answer", border_style="blue"))
+
+
+@main.command()
+@click.option("--repo", "-r", type=click.Path(exists=True), default=".", help="Repository path")
+def chat(repo: str):
+    """Interactive chat mode for querying the codebase."""
+    repo_path = Path(repo).resolve()
+    
+    tree = CodeTree(repo_path)
+    
+    if tree.index is None:
+        console.print("[yellow]No index found. Building index first...[/yellow]\n")
+        with console.status("[bold green]Indexing..."):
+            tree.build_index()
+    
+    console.print(Panel.fit(
+        "🌲 [bold]CodeTree Interactive Mode[/bold]\n\n"
+        f"Repository: [cyan]{repo_path.name}[/cyan]\n"
+        f"Files indexed: [green]{tree.index.total_files}[/green]\n\n"
+        "Type your questions about the code.\n"
+        "Commands: [dim]/tree, /stats, /find <symbol>, /quit[/dim]",
+        border_style="green",
+    ))
+    
+    while True:
+        try:
+            question = console.input("\n[bold cyan]You:[/bold cyan] ").strip()
+        except (EOFError, KeyboardInterrupt):
+            console.print("\n\n👋 Goodbye!")
+            break
+        
+        if not question:
+            continue
+        
+        if question.lower() in ("/quit", "/exit", "/q"):
+            console.print("\n👋 Goodbye!")
+            break
+        
+        if question.lower() == "/tree":
+            console.print("\n" + tree.tree(max_depth=3))
+            continue
+        
+        if question.lower() == "/stats":
+            stats = tree.stats()
+            console.print(Panel.fit(
+                f"Files: [bold]{stats['total_files']}[/bold]\n"
+                f"Lines: [bold]{stats['total_lines']:,}[/bold]\n"
+                f"Languages: {', '.join(f'{k}({v})' for k, v in stats['languages'].items())}",
+                title="Repository Stats",
+            ))
+            continue
+        
+        if question.lower().startswith("/find "):
+            symbol = question[6:].strip()
+            refs = tree.find(symbol)
+            if refs:
+                console.print(f"\n📍 Found [bold]{len(refs)}[/bold] references to '{symbol}':\n")
+                for ref in refs[:20]:
+                    console.print(f"  • [{ref['type']}] {ref['file']}: {ref.get('name', ref.get('statement', ''))}")
+            else:
+                console.print(f"\n[yellow]No references found for '{symbol}'[/yellow]")
+            continue
+        
+        # Regular question
+        with console.status("[bold green]Thinking..."):
+            answer = tree.query(question)
+        
+        console.print(f"\n[bold green]CodeTree:[/bold green]\n{answer}")
+
+
+@main.command()
+@click.option("--repo", "-r", type=click.Path(exists=True), default=".", help="Repository path")
+@click.option("--depth", "-d", type=int, default=3, help="Maximum tree depth")
+def tree(repo: str, depth: int):
+    """Show the code tree structure."""
+    repo_path = Path(repo).resolve()
+    
+    ct = CodeTree(repo_path)
+    
+    if ct.index is None:
+        console.print("[yellow]No index found. Building index first...[/yellow]\n")
+        with console.status("[bold green]Indexing..."):
+            ct.build_index()
+    
+    console.print(f"\n🌲 [bold]Code Tree:[/bold] {repo_path.name}\n")
+    console.print(ct.tree(max_depth=depth))
+
+
+@main.command()
+@click.argument("symbol")
+@click.option("--repo", "-r", type=click.Path(exists=True), default=".", help="Repository path")
+def find(symbol: str, repo: str):
+    """Find references to a symbol in the codebase."""
+    repo_path = Path(repo).resolve()
+    
+    ct = CodeTree(repo_path)
+    
+    if ct.index is None:
+        console.print("[yellow]No index found. Building index first...[/yellow]\n")
+        with console.status("[bold green]Indexing..."):
+            ct.build_index()
+    
+    refs = ct.find(symbol)
+    
+    if refs:
+        console.print(f"\n📍 Found [bold]{len(refs)}[/bold] references to '[cyan]{symbol}[/cyan]':\n")
+        for ref in refs:
+            if ref["type"] == "import":
+                console.print(f"  [dim]import[/dim]  {ref['file']}: {ref['statement']}")
+            else:
+                line_info = f":{ref['line']}" if ref.get('line') else ""
+                console.print(f"  [dim]{ref['type']:8}[/dim] {ref['file']}{line_info} → {ref['name']}")
+    else:
+        console.print(f"\n[yellow]No references found for '{symbol}'[/yellow]")
+
+
+@main.command()
+@click.option("--repo", "-r", type=click.Path(exists=True), default=".", help="Repository path")
+def stats(repo: str):
+    """Show statistics about the indexed repository."""
+    repo_path = Path(repo).resolve()
+    
+    ct = CodeTree(repo_path)
+    
+    if ct.index is None:
+        console.print("[red]No index found. Run 'codetree index' first.[/red]")
+        sys.exit(1)
+    
+    s = ct.stats()
+    
+    console.print(Panel.fit(
+        f"[bold]Repository:[/bold] {repo_path.name}\n"
+        f"[bold]Path:[/bold] {s['repo_path']}\n\n"
+        f"[bold]Files:[/bold] {s['total_files']}\n"
+        f"[bold]Lines:[/bold] {s['total_lines']:,}\n\n"
+        f"[bold]Languages:[/bold]\n" + 
+        "\n".join(f"  • {lang}: {count} files" for lang, count in s['languages'].items()) +
+        f"\n\n[dim]Indexed at: {s['created_at']}[/dim]",
+        title="📊 Repository Statistics",
+        border_style="blue",
+    ))
+
+
+if __name__ == "__main__":
+    main()

codetree/config.py

@@ -0,0 +1,110 @@
+"""Configuration management for CodeTree."""
+
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional
+import yaml
+
+
+@dataclass
+class LLMConfig:
+    """LLM provider configuration."""
+    provider: str = "openai"
+    model: str = "gpt-4o"
+    api_key: Optional[str] = None
+    base_url: Optional[str] = None
+    temperature: float = 0.0
+    max_tokens: int = 4096
+
+    def __post_init__(self):
+        # Resolve environment variables
+        if self.api_key and self.api_key.startswith("${") and self.api_key.endswith("}"):
+            env_var = self.api_key[2:-1]
+            self.api_key = os.environ.get(env_var)
+        
+        # Try default env vars if no key set
+        if not self.api_key:
+            if self.provider == "openai":
+                self.api_key = os.environ.get("OPENAI_API_KEY")
+            elif self.provider == "anthropic":
+                self.api_key = os.environ.get("ANTHROPIC_API_KEY")
+
+
+@dataclass
+class IndexConfig:
+    """Index configuration."""
+    languages: list[str] = field(default_factory=lambda: ["python", "javascript", "typescript", "go", "rust", "java"])
+    exclude: list[str] = field(default_factory=lambda: [
+        "node_modules", "__pycache__", ".git", ".venv", "venv", 
+        "dist", "build", ".egg-info", ".tox", ".pytest_cache"
+    ])
+    include_patterns: list[str] = field(default_factory=list)
+    max_file_size: int = 100_000  # bytes
+    max_files: int = 10_000
+
+
+@dataclass 
+class Config:
+    """Main configuration class."""
+    llm: LLMConfig = field(default_factory=LLMConfig)
+    index: IndexConfig = field(default_factory=IndexConfig)
+    cache_dir: Path = field(default_factory=lambda: Path.home() / ".cache" / "codetree")
+
+    @classmethod
+    def load(cls, config_path: Optional[Path] = None) -> "Config":
+        """Load configuration from file or defaults."""
+        config = cls()
+        
+        # Search for config file
+        search_paths = []
+        if config_path:
+            search_paths.append(config_path)
+        search_paths.extend([
+            Path.cwd() / ".codetree.yaml",
+            Path.cwd() / ".codetree.yml",
+            Path.home() / ".config" / "codetree" / "config.yaml",
+        ])
+        
+        for path in search_paths:
+            if path.exists():
+                config = cls.from_yaml(path)
+                break
+        
+        return config
+
+    @classmethod
+    def from_yaml(cls, path: Path) -> "Config":
+        """Load configuration from YAML file."""
+        with open(path) as f:
+            data = yaml.safe_load(f) or {}
+        
+        llm_data = data.get("llm", {})
+        index_data = data.get("index", {})
+        
+        return cls(
+            llm=LLMConfig(**llm_data),
+            index=IndexConfig(**index_data),
+            cache_dir=Path(data.get("cache_dir", Path.home() / ".cache" / "codetree")),
+        )
+
+    def to_yaml(self, path: Path) -> None:
+        """Save configuration to YAML file."""
+        data = {
+            "llm": {
+                "provider": self.llm.provider,
+                "model": self.llm.model,
+                "temperature": self.llm.temperature,
+                "max_tokens": self.llm.max_tokens,
+            },
+            "index": {
+                "languages": self.index.languages,
+                "exclude": self.index.exclude,
+                "max_file_size": self.index.max_file_size,
+            },
+            "cache_dir": str(self.cache_dir),
+        }
+        
+        path.parent.mkdir(parents=True, exist_ok=True)
+        with open(path, "w") as f:
+            yaml.dump(data, f, default_flow_style=False)

codetree/core.py

@@ -0,0 +1,179 @@
+"""Core CodeTree class - main entry point."""
+
+from pathlib import Path
+from typing import Optional
+
+from .config import Config
+from .indexer import CodeIndexer, CodeIndex
+from .retriever import CodeRetriever
+
+
+class CodeTree:
+    """
+    Main CodeTree class for indexing and querying code repositories.
+    
+    Example usage:
+        tree = CodeTree("/path/to/repo")
+        tree.build_index()
+        answer = tree.query("How does authentication work?")
+    """
+    
+    def __init__(
+        self, 
+        repo_path: str | Path,
+        config: Optional[Config] = None,
+    ):
+        """
+        Initialize CodeTree for a repository.
+        
+        Args:
+            repo_path: Path to the repository to index
+            config: Optional configuration object
+        """
+        self.repo_path = Path(repo_path).resolve()
+        self.config = config or Config.load()
+        self.indexer = CodeIndexer(self.config)
+        self._index: Optional[CodeIndex] = None
+        self._retriever: Optional[CodeRetriever] = None
+        
+        # Check for existing index
+        self._index_path = self._get_index_path()
+    
+    def _get_index_path(self) -> Path:
+        """Get the path where index should be stored."""
+        # Store in repo's .codetree directory
+        return self.repo_path / ".codetree" / "index.json"
+    
+    @property
+    def index(self) -> Optional[CodeIndex]:
+        """Get the current index, loading from disk if available."""
+        if self._index is None and self._index_path.exists():
+            self._index = self.indexer.load_index(self._index_path)
+        return self._index
+    
+    @property
+    def retriever(self) -> CodeRetriever:
+        """Get the retriever, initializing if needed."""
+        if self._retriever is None:
+            if self.index is None:
+                raise RuntimeError("No index available. Run build_index() first.")
+            self._retriever = CodeRetriever(self.index, self.config)
+        return self._retriever
+    
+    def build_index(self, save: bool = True) -> CodeIndex:
+        """
+        Build the code index for the repository.
+        
+        Args:
+            save: Whether to save the index to disk
+            
+        Returns:
+            The built CodeIndex
+        """
+        self._index = self.indexer.build_index(self.repo_path)
+        self._retriever = None  # Reset retriever
+        
+        if save:
+            self.indexer.save_index(self._index, self._index_path)
+        
+        return self._index
+    
+    def query(self, question: str) -> str:
+        """
+        Query the codebase with a natural language question.
+        
+        Args:
+            question: The question to ask about the code
+            
+        Returns:
+            Answer based on relevant code sections
+        """
+        return self.retriever.query(question)
+    
+    def find(self, symbol: str) -> list[dict]:
+        """
+        Find all occurrences of a symbol in the codebase.
+        
+        Args:
+            symbol: Symbol name to search for (function, class, etc.)
+            
+        Returns:
+            List of references found
+        """
+        if self.index is None:
+            raise RuntimeError("No index available. Run build_index() first.")
+        return self._find_references(symbol)
+    
+    def _find_references(self, symbol: str) -> list[dict]:
+        """Find all references to a symbol across the codebase (no LLM needed)."""
+        from .indexer import TreeNode
+        references = []
+        
+        def search_node(node: TreeNode):
+            if node.type == "file":
+                # Check functions
+                for func in node.functions:
+                    if symbol.lower() in func.get("name", "").lower():
+                        references.append({
+                            "type": "function",
+                            "file": node.path,
+                            "name": func["name"],
+                            "line": func.get("line"),
+                        })
+                
+                # Check classes
+                for cls in node.classes:
+                    if symbol.lower() in cls.get("name", "").lower():
+                        references.append({
+                            "type": "class",
+                            "file": node.path,
+                            "name": cls["name"],
+                            "line": cls.get("line"),
+                        })
+                
+                # Check imports
+                for imp in node.imports:
+                    if symbol.lower() in imp.lower():
+                        references.append({
+                            "type": "import",
+                            "file": node.path,
+                            "statement": imp,
+                        })
+            else:
+                for child in node.children:
+                    search_node(child)
+        
+        search_node(self.index.root)
+        return references
+    
+    def tree(self, max_depth: int = 3) -> str:
+        """
+        Get a text representation of the code tree.
+        
+        Args:
+            max_depth: Maximum depth to display
+            
+        Returns:
+            Tree structure as string
+        """
+        if self.index is None:
+            raise RuntimeError("No index available. Run build_index() first.")
+        return self.index.get_compact_tree(max_depth)
+    
+    def stats(self) -> dict:
+        """
+        Get statistics about the indexed repository.
+        
+        Returns:
+            Dictionary with stats (files, lines, languages, etc.)
+        """
+        if self.index is None:
+            raise RuntimeError("No index available. Run build_index() first.")
+        
+        return {
+            "repo_path": self.index.repo_path,
+            "total_files": self.index.total_files,
+            "total_lines": self.index.total_lines,
+            "languages": self.index.languages,
+            "created_at": self.index.created_at,
+        }