elastro-client 1.3.32__tar.gz → 1.3.36__tar.gz

{elastro_client-1.3.32/elastro_client.egg-info → elastro_client-1.3.36}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: elastro-client
-Version: 1.3.32
+Version: 1.3.36
 Summary: A comprehensive Python library for Elasticsearch management with both programmatic and CLI interfaces
 Author: Austin Jorgensen
 License-Expression: MIT
@@ -29,6 +29,11 @@ Requires-Dist: rich>=10.0.0
 Requires-Dist: rich-click>=1.7.0
 Requires-Dist: fastapi>=0.111.0
 Requires-Dist: uvicorn>=0.30.0
+Requires-Dist: tree-sitter>=0.23.0
+Requires-Dist: tree-sitter-python>=0.23.0
+Requires-Dist: tree-sitter-go>=0.23.0
+Requires-Dist: tree-sitter-javascript>=0.23.0
+Requires-Dist: tree-sitter-typescript>=0.23.0
 Provides-Extra: test
 Requires-Dist: pytest>=7.0.0; extra == "test"
 Requires-Dist: pytest-cov>=3.0.0; extra == "test"

{elastro_client-1.3.32 → elastro_client-1.3.36}/elastro/__init__.py

@@ -4,7 +4,7 @@ Elasticsearch Management Module.
 A module for managing Elasticsearch operations within a pipeline process.
 """
 
-__version__ = "1.3.32"
+__version__ = "1.3.36"
 
 # Core component imports
 from elastro.core.client import ElasticsearchClient

{elastro_client-1.3.32 → elastro_client-1.3.36}/elastro/cli/cli.py

@@ -4,10 +4,40 @@ Command-line interface main module.
 This module defines the main CLI structure using Click.
 """
 
+import sys
+
+# --- FAST PATH INTERCEPTOR ---
+# Must run before any other heavy imports to avoid the ~214ms startup penalty
+if len(sys.argv) >= 3 and sys.argv[1] == "doc" and sys.argv[2] == "search":
+    # Only use the fast path if '--help' is not requested
+    if "--help" not in sys.argv and "-h" not in sys.argv:
+        try:
+            import json
+            import urllib.request
+            from http.client import HTTPResponse
+            from typing import cast, Dict, Any
+
+            req = urllib.request.Request(
+                "http://127.0.0.1:9201/fast-path/doc/search",
+                data=json.dumps({"args": sys.argv[3:]}).encode("utf-8"),
+                headers={"Content-Type": "application/json"},
+                method="POST",
+            )
+            with urllib.request.urlopen(req, timeout=0.05) as _response:
+                response = cast(HTTPResponse, _response)
+                if getattr(response, "status", 0) == 200:
+                    print(response.read().decode("utf-8"), end="")
+                    sys.exit(0)
+        except Exception:
+            # If the daemon is offline or crashes, silently fall through
+            # to the normal heavy Click execution.
+            pass
+# --- END FAST PATH INTERCEPTOR ---
+
 import os
-import rich_click as click
 import json
 import yaml
+import rich_click as click
 from typing import Dict, Any, Optional, List, Union
 from rich.console import Console
 from rich.table import Table
@@ -244,6 +274,8 @@ utils.add_command(utils_templates)
 utils.add_command(aliases)
 
 from elastro.cli.commands.gui import gui
+from elastro.cli.commands.rag import rag_group
+from elastro.cli.commands.daemon import daemon_group
 
 # Register Top-Level Groups
 cli.add_command(template_group)
@@ -257,6 +289,8 @@ cli.add_command(ml_group)
 cli.add_command(script_group)
 cli.add_command(painless_group)
 cli.add_command(gui)
+cli.add_command(rag_group)
+cli.add_command(daemon_group)
 
 
 def main() -> None:

elastro_client-1.3.36/elastro/cli/commands/daemon.py

@@ -0,0 +1,60 @@
+"""
+Daemon management commands.
+"""
+
+# fmt: off
+
+import sys
+import urllib.request
+
+import rich_click as click
+
+
+@click.group("daemon")
+def daemon_group() -> None:
+    """
+    Manage the Fast-Path Agentic Daemon.
+    """
+    pass
+
+
+@daemon_group.command("start")
+@click.option("--port", type=int, default=9201, help="Port to run the daemon on")
+@click.option(
+    "--host", type=str, default="127.0.0.1", help="Host to bind the daemon to"
+)
+def start(port: int, host: str) -> None:
+    """
+    Start the Fast-Path CLI Daemon.
+
+    Keeps the Elasticsearch connection hot in memory so subsequent agents querying via
+    'elastro doc search' will bypass the slow Python startup sequence.
+    """
+    try:
+        from elastro.core.daemon import start_daemon
+
+        click.echo(f"Starting Elastro Daemon on {host}:{port}...")
+        start_daemon(host=host, port=port)
+    except ImportError as e:
+        click.echo(f"Failed to load daemon dependencies: {e}", err=True)
+        sys.exit(1)
+
+
+@daemon_group.command("status")
+@click.option("--port", type=int, default=9201, help="Port the daemon is running on")
+def status(port: int) -> None:
+    """Check if the Daemon is active."""
+    try:
+        import urllib.request
+        from http.client import HTTPResponse
+        from typing import cast
+
+        req = urllib.request.Request(f"http://127.0.0.1:{port}/health")
+        with urllib.request.urlopen(req, timeout=1.0) as _response:
+            response = cast(HTTPResponse, _response)
+            if getattr(response, "status", 0) == 200:
+                click.echo("Daemon is ONLINE and responding.")
+            else:
+                click.echo(f"Daemon returned status: {getattr(response, 'status', 'unknown')}")
+    except Exception as e:
+        click.echo(f"Daemon is OFFLINE. ({e})")

elastro_client-1.3.36/elastro/cli/commands/rag.py

@@ -0,0 +1,72 @@
+"""
+Graph RAG Commands for Code Flow Mapping.
+"""
+
+import rich_click as click
+import os
+from typing import Optional
+from elastro.core.client import ElasticsearchClient
+from elastro.core.rag.ingestor import GraphRAGManager
+from elastro.cli.output import format_output
+from rich.console import Console
+
+console = Console()
+
+
+@click.group("rag")
+def rag_group() -> None:
+    """
+    Manage Graph RAG (Retrieval Augmented Generation) capabilities.
+
+    Includes native Code Flow mapping, AST extraction for Python, Go, TypeScript, and Vue,
+    and direct injection into local Elasticsearch for Agentic Codebase Memory.
+    """
+    pass
+
+
+@rag_group.command("ingest")
+@click.argument(
+    "repo_path", type=click.Path(exists=True, file_okay=False, dir_okay=True)
+)
+@click.option(
+    "--index",
+    "-i",
+    type=str,
+    default="fremen_codebase_rag",
+    help="Target Elasticsearch index name (default: fremen_codebase_rag)",
+)
+@click.pass_obj
+def ingest_repo(client: ElasticsearchClient, repo_path: str, index: str) -> None:
+    """
+    Ingest a repository with AST Code Flow Mapping.
+
+    This command scans your codebase, utilizes Tree-sitter polyglot AST parsers
+    to extract 'functions_defined' and 'functions_called', and uses the
+    Elasticsearch Bulk API to stripe the Graph RAG data perfectly into an index.
+
+    Example:
+    ```bash
+    elastro rag ingest /path/to/my/go-repo
+    ```
+    """
+    repo_name = os.path.basename(os.path.abspath(repo_path))
+    console.print(
+        f"[bold cyan]🔍 Initializing Graph RAG AST Parsing for '{repo_name}'[/bold cyan]"
+    )
+
+    manager = GraphRAGManager(client, index)
+
+    try:
+        # We handle index scaffolding internally in GraphRAGManager
+        success_count = manager.ingest_repository(repo_path)
+
+        console.print(
+            f"[bold green]✅ Success![/bold green] Ingested and mapped Code Flows for [bold]{success_count}[/bold] files."
+        )
+        console.print(
+            f"[dim]The AST Graph RAG context is now active in index '{index}'.[/dim]"
+        )
+
+    except Exception as e:
+        console.print(f"[bold red]❌ RAG Ingestion Failed:[/bold red] {str(e)}")
+        exit(1)

{elastro_client-1.3.32 → elastro_client-1.3.36}/elastro/core/client.py

@@ -1,3 +1,4 @@
+# mypy: ignore-errors
 """
 Elasticsearch client module.
 

elastro_client-1.3.36/elastro/core/daemon.py

@@ -0,0 +1,132 @@
+"""
+Elastro Fast-Path Daemon.
+
+Maintains a persistent Elasticsearch client for sub-millisecond agentic queries.
+"""
+
+import argparse
+from contextlib import asynccontextmanager
+from typing import List, Optional, AsyncGenerator, Any, Dict
+
+import uvicorn
+from fastapi import FastAPI, Request
+from fastapi.responses import PlainTextResponse
+from pydantic import BaseModel
+
+from elastro.cli.output import format_output
+from elastro.config.loader import get_config
+from elastro.core.client import ElasticsearchClient
+from elastro.core.document import DocumentManager
+from elastro.core.query_builder import QueryBuilder
+
+# Global client
+client: Optional[ElasticsearchClient] = None
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
+    global client
+    config = get_config()
+    client = ElasticsearchClient(
+        hosts=config["elasticsearch"]["hosts"],
+        auth=config["elasticsearch"].get("auth"),
+        timeout=config["elasticsearch"].get("timeout", 30),
+        retry_on_timeout=config["elasticsearch"].get("retry_on_timeout", True),
+        max_retries=config["elasticsearch"].get("max_retries", 3),
+    )
+    client.connect()
+    yield
+    if client:
+        client.disconnect()
+
+
+app = FastAPI(lifespan=lifespan, title="Elastro Agentic Daemon")
+
+
+class DocSearchRequest(BaseModel):
+    args: List[str]
+
+
+@app.get("/health")
+def health_check() -> Dict[str, Any]:
+    return {
+        "status": "alive",
+        "client_connected": client.is_connected() if client else False,
+    }
+
+
+@app.post("/fast-path/doc/search")
+async def fast_path_search(req: DocSearchRequest) -> PlainTextResponse:
+    # Parse args manually for top 10 query types
+    parser = argparse.ArgumentParser()
+    parser.add_argument("index", type=str)
+    parser.add_argument("query", type=str, nargs="?", default=None)
+    parser.add_argument("--size", type=int, default=10)
+    parser.add_argument("--from", "from_", type=int, default=0, dest="from_")
+
+    # Query types
+    parser.add_argument("--match", action="append", default=[])
+    parser.add_argument(
+        "--match-phrase", action="append", default=[], dest="match_phrase"
+    )
+    parser.add_argument("--term", action="append", default=[])
+    parser.add_argument("--terms", action="append", default=[])
+    parser.add_argument("--range", action="append", default=[])
+    parser.add_argument("--prefix", action="append", default=[])
+    parser.add_argument("--wildcard", action="append", default=[])
+    parser.add_argument("--exists", action="append", default=[])
+    parser.add_argument("--ids", action="append", default=[])
+    parser.add_argument("--fuzzy", action="append", default=[])
+
+    # Excludes
+    parser.add_argument(
+        "--exclude-match", action="append", default=[], dest="exclude_match"
+    )
+    parser.add_argument(
+        "--exclude-term", action="append", default=[], dest="exclude_term"
+    )
+
+    parser.add_argument("--output", "-o", type=str, default="json")
+
+    parsed, _ = parser.parse_known_args(req.args)
+
+    if not client:
+        return PlainTextResponse(
+            "Error: Elasticsearch client not connected in daemon.", status_code=500
+        )
+
+    doc_manager = DocumentManager(client)
+
+    inner_query = QueryBuilder.build_bool_query(
+        must_match=getattr(parsed, "match", None),
+        must_match_phrase=getattr(parsed, "match_phrase", None),
+        must_term=getattr(parsed, "term", None),
+        must_terms=getattr(parsed, "terms", None),
+        must_range=getattr(parsed, "range", None),
+        must_prefix=getattr(parsed, "prefix", None),
+        must_wildcard=getattr(parsed, "wildcard", None),
+        must_exists=getattr(parsed, "exists", None),
+        must_ids=getattr(parsed, "ids", None),
+        must_fuzzy=getattr(parsed, "fuzzy", None),
+        exclude_match=getattr(parsed, "exclude_match", None),
+        exclude_term=getattr(parsed, "exclude_term", None),
+        query_string=getattr(parsed, "query", None),
+    )
+
+    query_body = {"query": inner_query}
+    options = {"size": getattr(parsed, "size", 10), "from": getattr(parsed, "from_", 0)}
+
+    try:
+        results = doc_manager.search(getattr(parsed, "index", ""), query_body, options)
+        output_format = getattr(parsed, "output", "json")
+        output_str = format_output(results, output_format=output_format)
+        return PlainTextResponse(content=output_str)
+    except Exception as e:
+        return PlainTextResponse(
+            content=f"Daemon search error: {str(e)}", status_code=500
+        )
+
+
+def start_daemon(host: str = "127.0.0.1", port: int = 9201) -> None:
+    """Start the Elastro daemon server."""
+    uvicorn.run(app, host=host, port=port, log_level="info")

{elastro_client-1.3.32 → elastro_client-1.3.36}/elastro/core/document.py

@@ -74,7 +74,7 @@ class DocumentManager:
 
             logger.debug(f"Indexing document into '{index}' with ID '{id}'")
             # Execute the index operation
-            response = self.client.client.index(**params)
+            response = self.client.client.index(**params)  # type: ignore
             return response.body if hasattr(response, "body") else dict(response)
         except Exception as e:
             logger.error(f"Failed to index document info '{index}': {str(e)}")
@@ -355,7 +355,7 @@ class DocumentManager:
 
         try:
             logger.debug(f"Searching index '{index}'...")
-            response = self.client.client.search(**search_params)
+            response = self.client.client.search(**search_params)  # type: ignore
             return response.body if hasattr(response, "body") else dict(response)
         except Exception as e:
             logger.error(f"Failed to search documents in '{index}': {str(e)}")

{elastro_client-1.3.32 → elastro_client-1.3.36}/elastro/core/document_bulk.py

@@ -74,7 +74,7 @@ class BulkDocumentManager:
             # Execute bulk operation
             return self.client.client.bulk(
                 operations=operations, refresh="true" if refresh else "false"
-            )
+            )  # type: ignore
         except Exception as e:
             raise DocumentError(f"Failed to bulk index documents: {str(e)}")
 
@@ -112,6 +112,6 @@ class BulkDocumentManager:
             # Execute bulk operation
             return self.client.client.bulk(
                 operations=operations, refresh="true" if refresh else "false"
-            )
+            )  # type: ignore
         except Exception as e:
             raise DocumentError(f"Failed to bulk delete documents: {str(e)}")

elastro_client-1.3.36/elastro/core/rag/ast_parser.py

@@ -0,0 +1,261 @@
+# mypy: ignore-errors
+"""
+Abstract Syntax Tree (AST) parser utilizing tree-sitter for Graph RAG Code Flow Mapping.
+Supports polyglot analysis of Python, Go, JavaScript, TypeScript, and Vue.
+Implements Semantic Chunking and Signature Extraction.
+"""
+
+import os
+import tree_sitter  # type: ignore
+from typing import Dict, List, Set, Any
+
+
+class ASTParser:
+    def __init__(self) -> None:
+        self.parsers: Dict[str, tree_sitter.Parser] = {}
+        self._initialize_parsers()
+
+    def _initialize_parsers(self) -> None:
+        """Loads natively compiled tree-sitter language capsules."""
+        try:
+            from tree_sitter import Language, Parser
+            import tree_sitter_python as tsp  # type: ignore
+            import tree_sitter_go as tsg  # type: ignore
+            import tree_sitter_javascript as tsjs  # type: ignore
+            import tree_sitter_typescript as tsts  # type: ignore
+
+            # v0.25+ API natively imports .language() as PyCapsule pointers
+            self.langs = {
+                "python": Language(tsp.language()),
+                "go": Language(tsg.language()),
+                "javascript": Language(tsjs.language()),
+                "typescript": Language(tsts.language_typescript()),
+                # Vue uses specialized HTML embedding, but for script logic, TS/JS parser handles it well
+                "vue": Language(tsts.language_typescript()),
+            }
+
+            for lang_name, lang_obj in self.langs.items():
+                parser = Parser()
+                parser.language = lang_obj
+                self.parsers[lang_name] = parser
+
+        except ImportError as e:
+            # Degrade gracefully if tree-sitter is missing during testing/CI
+            print(f"Graph RAG AST Parser initialization warning: {e}")
+            pass
+
+    def _determine_language(self, ext: str) -> str:
+        ext = ext.lower()
+        if ext == ".py":
+            return "python"
+        elif ext == ".go":
+            return "go"
+        elif ext in [".js", ".jsx"]:
+            return "javascript"
+        elif ext in [".ts", ".tsx"]:
+            return "typescript"
+        elif ext == ".vue":
+            return "vue"
+        return "unsupported"
+
+    def parse_file(self, file_path: str, content: str) -> List[Dict[str, Any]]:
+        """
+        Parses raw code and extracts semantic chunks (functions/classes) with deterministic call graphs.
+        """
+        ext = os.path.splitext(file_path)[1]
+        lang = self._determine_language(ext)
+
+        if lang not in self.parsers:
+            return [
+                {
+                    "chunk_type": "file",
+                    "name": "module",
+                    "content": content,
+                    "functions_defined": [],
+                    "functions_called": [],
+                }
+            ]
+
+        parser = self.parsers[lang]
+        source = content.encode("utf-8")
+        tree = parser.parse(source)
+
+        chunks: List[Dict[str, Any]] = []
+
+        self._extract_chunks(tree.root_node, lang, source, chunks)
+
+        # If no semantic chunks were found, fallback to parsing the whole file as a single module chunk
+        if not chunks:
+            called: Set[str] = set()
+            self._traverse_for_calls(tree.root_node, lang, source, called)
+            chunks.append(
+                {
+                    "chunk_type": "file",
+                    "name": "module",
+                    "content": content,
+                    "functions_defined": [],
+                    "functions_called": sorted(list(called)),
+                }
+            )
+
+        return chunks
+
+    def _extract_chunks(
+        self,
+        node: tree_sitter.Node,
+        lang: str,
+        source: bytes,
+        chunks: List[Dict[str, Any]],
+    ) -> None:
+        """Recursive AST Walk for semantic chunking."""
+        node_type = node.type
+
+        is_chunk = False
+        chunk_name = ""
+        chunk_type = ""
+
+        if lang == "python":
+            if node_type in ["function_definition", "class_definition"]:
+                is_chunk = True
+                chunk_type = "function" if "function" in node_type else "class"
+                name_node = node.child_by_field_name("name")
+                if name_node:
+                    chunk_name = source[
+                        name_node.start_byte : name_node.end_byte
+                    ].decode("utf-8")
+
+        elif lang == "go":
+            if node_type in [
+                "function_declaration",
+                "method_declaration",
+                "type_declaration",
+            ]:
+                is_chunk = True
+                chunk_type = (
+                    "function"
+                    if "function" in node_type or "method" in node_type
+                    else "class"
+                )
+                name_node = node.child_by_field_name("name")
+                if name_node:
+                    chunk_name = source[
+                        name_node.start_byte : name_node.end_byte
+                    ].decode("utf-8")
+
+        elif lang in ["javascript", "typescript", "vue"]:
+            if node_type in [
+                "function_declaration",
+                "method_definition",
+                "class_declaration",
+            ]:
+                is_chunk = True
+                chunk_type = (
+                    "function"
+                    if "function" in node_type or "method" in node_type
+                    else "class"
+                )
+                name_node = node.child_by_field_name("name")
+                if name_node:
+                    chunk_name = source[
+                        name_node.start_byte : name_node.end_byte
+                    ].decode("utf-8")
+            elif node_type == "variable_declarator":
+                name_node = node.child_by_field_name("name")
+                val_node = node.child_by_field_name("value")
+                if name_node and val_node and val_node.type == "arrow_function":
+                    is_chunk = True
+                    chunk_type = "function"
+                    chunk_name = source[
+                        name_node.start_byte : name_node.end_byte
+                    ].decode("utf-8")
+
+        if is_chunk:
+            called: Set[str] = set()
+            # Traverse specifically inside this chunk's boundaries to extract calls
+            self._traverse_for_calls(node, lang, source, called)
+
+            # To ensure proper context window, extract the source of just this node
+            chunk_content = source[node.start_byte : node.end_byte].decode("utf-8")
+
+            chunks.append(
+                {
+                    "chunk_type": chunk_type,
+                    "name": chunk_name or "anonymous",
+                    "content": chunk_content,
+                    "functions_defined": [chunk_name] if chunk_name else [],
+                    "functions_called": sorted(list(called)),
+                }
+            )
+
+        # Continue recursing to find nested functions/classes (e.g., methods inside a class)
+        for child in node.children:
+            self._extract_chunks(child, lang, source, chunks)
+
+    def _traverse_for_calls(
+        self, node: tree_sitter.Node, lang: str, source: bytes, called: Set[str]
+    ) -> None:
+        """Extracts call chains including their parameters/arguments for exact signature mapping."""
+        if node.type == "call_expression":
+            func_node = node.child_by_field_name("function")
+            if func_node:
+                call_text = self._extract_call_chain(func_node, source)
+
+                ignore_list = {
+                    "print",
+                    "len",
+                    "range",
+                    "str",
+                    "int",
+                    "list",
+                    "dict",
+                    "set",
+                    "super",
+                    "append",
+                    "fmt.Println",
+                    "console.log",
+                    "console.error",
+                    "require",
+                    "getattr",
+                    "setattr",
+                    "hasattr",
+                    "isinstance",
+                    "type",
+                }
+
+                if call_text and call_text not in ignore_list:
+                    # Signature Extraction: Pull the arguments as well
+                    args_node = node.child_by_field_name("arguments")
+                    if args_node:
+                        args_text = source[
+                            args_node.start_byte : args_node.end_byte
+                        ].decode("utf-8")
+                        # Sanitize whitespace/newlines
+                        args_text = " ".join(args_text.split())
+                        if len(args_text) < 60:
+                            call_text = f"{call_text}{args_text}"
+
+                    if len(call_text) < 120 and "\n" not in call_text:
+                        called.add(call_text)
+
+        for child in node.children:
+            self._traverse_for_calls(child, lang, source, called)
+
+    def _extract_call_chain(self, node: tree_sitter.Node, source: bytes) -> str:
+        """Recursively builds pure string representation of chained object method calls."""
+        if node.type == "identifier":
+            return source[node.start_byte : node.end_byte].decode("utf-8")
+        elif node.type == "attribute":
+            obj_node = node.child_by_field_name("object")
+            attr_node = node.child_by_field_name("attribute")
+            if obj_node and attr_node:
+                obj_str = self._extract_call_chain(obj_node, source)
+                attr_str = source[attr_node.start_byte : attr_node.end_byte].decode(
+                    "utf-8"
+                )
+                return f"{obj_str}.{attr_str}"
+        elif node.type == "call":
+            func_node = node.child_by_field_name("function")
+            if func_node:
+                return self._extract_call_chain(func_node, source)
+
+        return source[node.start_byte : node.end_byte].decode("utf-8").strip()