eulerian 0.1.0__py3-none-any.whl

eulerian/__init__.py

@@ -0,0 +1 @@
+"""eulerian — standalone real-time code index for local directories and git repos."""

eulerian/cli.py

@@ -0,0 +1,197 @@
+"""eulerian CLI — watch, outline, find, status, repo."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+app = typer.Typer(
+    name="eulerian",
+    help="Real-time code index for local directories and git repos.",
+    no_args_is_help=True,
+)
+console = Console()
+
+
+@app.command()
+def watch(
+    path: Path = typer.Argument(
+        Path("."), help="Directory to watch (default: current directory)"
+    ),
+    http: bool = typer.Option(
+        False, "--http", help="Serve MCP over HTTP instead of stdio"
+    ),
+    host: str = typer.Option("0.0.0.0", "--host", help="Bind host (http mode only)"),
+    port: int = typer.Option(8090, "--port", help="Bind port (http mode only)"),
+) -> None:
+    """Start watching a directory and serve the MCP server (stdio or http).
+
+    Performs a full scan immediately, then keeps the index live via a
+    filesystem watcher for the lifetime of this process.
+    """
+    import asyncio
+
+    from .sources import local as _local
+    from .state import index
+    from .mcp.server import server as mcp_server
+
+    root = path.expanduser().resolve()
+    if not root.is_dir():
+        console.print(f"[red]Not a directory:[/red] {root}")
+        raise typer.Exit(1)
+
+    watcher = _local.watch_root(index, root)
+    console.print(
+        f"[green]eulerian[/green] watching {watcher.root} ({watcher.symbol_count} symbols)"
+    )
+
+    if http:
+        console.print(f"  MCP (http) listening on {host}:{port}")
+        asyncio.run(mcp_server.run_http_async(host=host, port=port))
+    else:
+        asyncio.run(mcp_server.run_stdio_async())
+
+
+@app.command()
+def outline(
+    query: str = typer.Argument(..., help="Symbol name or file path fragment"),
+    path: Path = typer.Argument(
+        Path("."), help="Directory to search (default: current directory)"
+    ),
+    k: int = typer.Option(20, help="Max results"),
+) -> None:
+    """One-shot fuzzy symbol search — parses path, searches, exits. No persistent watcher."""
+    from .index import Index
+
+    root = path.expanduser().resolve()
+    idx = Index()
+    idx.full_scan(root, root)
+    symbols = idx.outline(root, query, k)
+    if not symbols:
+        console.print(f"[dim]No symbols found for[/dim] {query!r}")
+        return
+    for s in symbols:
+        console.print(
+            f"  [cyan]{s.name}[/cyan] [L{s.start}-{s.end}] ({s.kind})  [dim]{s.file}[/dim]"
+        )
+
+
+@app.command()
+def find(
+    symbol: str = typer.Argument(..., help="Symbol name or substring"),
+    path: Path = typer.Argument(
+        Path("."), help="Directory to search (default: current directory)"
+    ),
+) -> None:
+    """One-shot symbol lookup by name — parses path, searches, exits."""
+    from .index import Index
+
+    root = path.expanduser().resolve()
+    idx = Index()
+    idx.full_scan(root, root)
+    symbols = idx.find(root, symbol)
+    if not symbols:
+        console.print(f"[dim]No symbol found matching[/dim] {symbol!r}")
+        return
+    for s in symbols:
+        console.print(
+            f"  [cyan]{s.name}[/cyan] [L{s.start}-{s.end}]  [dim]{s.file}[/dim]"
+        )
+
+
+@app.command()
+def status(
+    path: Path = typer.Argument(
+        Path("."), help="Directory to scan (default: current directory)"
+    ),
+) -> None:
+    """One-shot scan summary — files indexed, symbol count, by kind."""
+    from .parser import parse_directory
+
+    root = path.expanduser().resolve()
+    result = parse_directory(root)
+    by_kind: dict[str, int] = {}
+    for s in result.symbols:
+        by_kind[s.kind] = by_kind.get(s.kind, 0) + 1
+    console.print(f"[bold]{root}[/bold]")
+    console.print(
+        f"  files indexed: {result.files_indexed}  skipped: {result.files_skipped}"
+    )
+    for kind, count in sorted(by_kind.items()):
+        console.print(f"  {kind}: {count}")
+
+
+# ---------------------------------------------------------------------------
+# repo subcommands — operate on the persistent registry/worktree pool
+# ---------------------------------------------------------------------------
+
+repo_app = typer.Typer(
+    name="repo", help="Registered-git-repo worktree management.", no_args_is_help=True
+)
+app.add_typer(repo_app)
+
+
+@repo_app.command("add")
+def repo_add_cmd(url: str = typer.Argument(..., help="Git remote URL")) -> None:
+    """Clone url as a bare clone and register it."""
+    from .sources import repo as _repo
+
+    result = _repo.repo_add(url)
+    console.print(json.dumps(result, indent=2))
+
+
+@repo_app.command("list")
+def repo_list_cmd() -> None:
+    """List all registered repos."""
+    from .sources import repo as _repo
+
+    console.print(json.dumps(_repo.repo_list(), indent=2))
+
+
+@repo_app.command("fetch")
+def repo_fetch_cmd(
+    repo: str = typer.Argument(..., help="Registered repo name or URL"),
+) -> None:
+    """Fetch the latest refs for a registered repo."""
+    from .sources import repo as _repo
+
+    console.print(json.dumps(_repo.repo_fetch(repo), indent=2))
+
+
+@repo_app.command("checkout")
+def repo_checkout_cmd(
+    repo: str = typer.Argument(..., help="Registered repo name or URL"),
+    ref: str = typer.Argument(..., help="Branch, tag, or commit hash"),
+    user: str = typer.Option("default", "--user", "-u"),
+) -> None:
+    """Create or reuse a worktree for repo+ref."""
+    from .index import Index
+    from .sources import repo as _repo
+
+    idx = Index()
+    console.print(json.dumps(_repo.code_checkout(idx, repo, ref, user), indent=2))
+
+
+@repo_app.command("outline")
+def repo_outline_cmd(
+    repo: str = typer.Argument(...),
+    ref: str = typer.Argument(...),
+    query: str = typer.Argument(...),
+    user: str = typer.Option("default", "--user", "-u"),
+    k: int = typer.Option(20),
+) -> None:
+    """Fuzzy symbol search over a checked-out worktree (checkout first)."""
+    from .index import Index
+    from .sources import repo as _repo
+
+    idx = Index()
+    symbols, warnings = _repo.query_outline(idx, user, repo, ref, query, k)
+    for s in symbols:
+        console.print(
+            f"  [cyan]{s.name}[/cyan] [L{s.start}-{s.end}] ({s.kind})  [dim]{s.file}[/dim]"
+        )
+    for w in warnings:
+        console.print(f"[yellow]WARNING:[/yellow] {w}")

eulerian/index.py

@@ -0,0 +1,127 @@
+"""In-memory symbol index, keyed by an opaque handle.
+
+A handle is whatever the caller wants — a resolved local root path, or a
+(user, repo, ref) tuple for repo-mode. The index itself doesn't care; it
+just holds a symbol list per handle and answers outline/find/read-adjacent
+queries against it. Local-mode and repo-mode sources both populate the same
+index through full_scan/update_file/remove_file.
+"""
+
+from __future__ import annotations
+
+import threading
+from pathlib import Path
+from typing import Hashable
+
+from rapidfuzz import fuzz, process
+
+from .parser import (
+    Symbol,
+    build_module_map,
+    parse_directory,
+    parse_file,
+    walk_python_files,
+)
+
+Handle = Hashable
+
+
+class Index:
+    def __init__(self) -> None:
+        self._lock = threading.Lock()
+        self._symbols: dict[Handle, list[Symbol]] = {}
+        self._roots: dict[Handle, Path] = {}
+        self._module_maps: dict[Handle, dict[str, str]] = {}
+
+    def full_scan(self, handle: Handle, root: Path) -> int:
+        """Walk + parse everything under root, replacing any existing index for handle."""
+        result = parse_directory(root)
+        module_map = build_module_map(root, walk_python_files(root))
+        with self._lock:
+            self._symbols[handle] = result.symbols
+            self._roots[handle] = root
+            self._module_maps[handle] = module_map
+        return len(result.symbols)
+
+    def update_file(self, handle: Handle, path: Path) -> None:
+        """Re-parse a single file and replace its symbols in the index."""
+        root = self._roots.get(handle)
+        if root is None:
+            return
+        try:
+            rel = str(path.relative_to(root)).replace("\\", "/")
+        except ValueError:
+            return
+        file_result = parse_file(path, root, self._module_maps.get(handle))
+        with self._lock:
+            existing = self._symbols.get(handle, [])
+            kept = [s for s in existing if s.file != rel]
+            self._symbols[handle] = kept + (
+                [] if file_result.skipped else file_result.symbols
+            )
+
+    def remove_file(self, handle: Handle, path: Path) -> None:
+        """Drop all symbols for a deleted file."""
+        root = self._roots.get(handle)
+        if root is None:
+            return
+        try:
+            rel = str(path.relative_to(root)).replace("\\", "/")
+        except ValueError:
+            return
+        with self._lock:
+            existing = self._symbols.get(handle)
+            if existing is not None:
+                self._symbols[handle] = [s for s in existing if s.file != rel]
+
+    def evict(self, handle: Handle) -> None:
+        with self._lock:
+            self._symbols.pop(handle, None)
+            self._roots.pop(handle, None)
+            self._module_maps.pop(handle, None)
+
+    def has(self, handle: Handle) -> bool:
+        with self._lock:
+            return handle in self._symbols
+
+    def get_root(self, handle: Handle) -> Path | None:
+        return self._roots.get(handle)
+
+    def get_symbols(self, handle: Handle) -> list[Symbol] | None:
+        with self._lock:
+            symbols = self._symbols.get(handle)
+            return list(symbols) if symbols is not None else None
+
+    def outline(self, handle: Handle, query: str, k: int = 20) -> list[Symbol]:
+        """Fuzzy lexical search over symbol names and file paths."""
+        symbols = self.get_symbols(handle) or []
+        if not symbols:
+            return []
+        choices = [f"{s.name} {s.file}" for s in symbols]
+        results = process.extract(
+            query, choices, scorer=fuzz.WRatio, limit=k, score_cutoff=35
+        )
+        return [symbols[idx] for _, _, idx in results]
+
+    def outline_paths(
+        self, handle: Handle, paths: list[str]
+    ) -> tuple[list[Symbol], list[str]]:
+        """Exact-file symbol outline lookup for a batch of paths, bypassing fuzzy search."""
+        symbols = self.get_symbols(handle) or []
+        by_file: dict[str, list[Symbol]] = {}
+        for s in symbols:
+            by_file.setdefault(s.file, []).append(s)
+
+        matched: list[Symbol] = []
+        warnings: list[str] = []
+        for p in paths:
+            if p in by_file:
+                matched.extend(by_file[p])
+            else:
+                warnings.append(f"no symbols found for path: {p!r}")
+        return matched, warnings
+
+    def find(self, handle: Handle, symbol: str) -> list[Symbol]:
+        """Substring match by symbol name."""
+        symbols = self.get_symbols(handle) or []
+        return [s for s in symbols if symbol in s.name]

eulerian/mcp/__init__.py

@@ -0,0 +1 @@
+"""eulerian MCP server package."""

eulerian/mcp/_instance.py

@@ -0,0 +1,14 @@
+"""FastMCP singleton — leaf module with no package imports."""
+
+from fastmcp import FastMCP
+
+server = FastMCP(
+    name="eulerian",
+    instructions=(
+        "Real-time code navigation. Local mode: call watch(path) once, then "
+        "outline/find/read against it — the index reflects on-disk edits "
+        "instantly, no re-indexing calls needed. Repo mode: repo_add a git "
+        "remote, checkout a ref, then repo_outline/repo_read against it — "
+        "freshness is checked against the remote on each call."
+    ),
+)

eulerian/mcp/server.py

@@ -0,0 +1,7 @@
+"""FastMCP server entry point — importing tools registers their @server.tool() decorators."""
+
+from __future__ import annotations
+
+from ._instance import server  # noqa: F401 — re-exported; callers do `from .mcp.server import server`
+
+from . import tools  # noqa: F401, E402