raggiecode 0.2.1__py3-none-any.whl

RAG/find.py

@@ -0,0 +1,408 @@
+from pathlib import Path
+
+from indexing.code_index_sdk import CodeIndexSDK
+
+
+def search_descriptions(query: str, symbol_types: list = None, limit: int = 50) -> str:
+    """Search for symbols by description content.
+
+    Args:
+        query: Search query string
+        symbol_types: Optional list of symbol types to search (e.g., ['function', 'class'])
+        limit: Maximum number of results to return
+
+    Returns:
+        Formatted string with search results
+    """
+    db_path = Path.cwd() / ".raggie" / ".code_index.raggie"
+    
+    if not db_path.exists():
+        return f"Error: Code index database not found at {db_path}"
+    
+    try:
+        with CodeIndexSDK(str(db_path)) as sdk:
+            results = sdk.search_descriptions(query, symbol_types, limit)
+            
+            if not results:
+                return f"No symbols found with descriptions matching '{query}'"
+            
+            lines = [f"Found {len(results)} symbols with descriptions matching '{query}':"]
+            for r in results:
+                lines.append(f"  - {r['type']}: {r['name']} in {r['file_path']}")
+                lines.append(f"    Description: {r['description']}")
+            
+            return "\n".join(lines)
+    except Exception as e:
+        return f"Error searching descriptions: {str(e)}"
+
+
+def get_undocumented_symbols(symbol_types: list = None, file_path: str = None) -> str:
+    """Get symbols that have no description.
+
+    Args:
+        symbol_types: Optional list of symbol types to check (e.g., ['function', 'class'])
+        file_path: Optional file path to filter by file
+
+    Returns:
+        Formatted string with undocumented symbols
+    """
+    db_path = Path.cwd() / ".raggie" / ".code_index.raggie"
+    
+    if not db_path.exists():
+        return f"Error: Code index database not found at {db_path}"
+    
+    try:
+        with CodeIndexSDK(str(db_path)) as sdk:
+            file_id = None
+            if file_path:
+                file = sdk.get_file_by_path(file_path)
+                if file:
+                    file_id = file.id
+                else:
+                    return f"Error: File not found in database: {file_path}"
+            
+            undocumented = sdk.get_undocumented_symbols(symbol_types, file_id)
+            
+            if not undocumented:
+                return "All symbols have descriptions" + (f" in {file_path}" if file_path else "")
+            
+            lines = [f"Undocumented symbols" + (f" in {file_path}" if file_path else "") + ":"]
+            for symbol_type, symbols in undocumented.items():
+                lines.append(f"\n  {symbol_type}s ({len(symbols)}):")
+                for s in symbols:
+                    lines.append(f"    - {s['name']} in {s['file_path']}")
+            
+            return "\n".join(lines)
+    except Exception as e:
+        return f"Error getting undocumented symbols: {str(e)}"
+
+
+def find_symbol_location(symbol_name: str, file_path: str = None):
+    """Find the file path, line range, and current source of a symbol.
+
+    Args:
+        symbol_name: Name of the symbol to find
+        file_path: Optional file path to disambiguate same-name symbols
+
+    Returns:
+        dict with keys: file_path, start_line, end_line, source, kind
+        or None if not found
+    """
+    db_path = Path.cwd() / ".raggie" / ".code_index.raggie"
+
+    if not db_path.exists():
+        return None
+
+    try:
+        with CodeIndexSDK(str(db_path)) as sdk:
+            file_id = None
+            if file_path:
+                f = sdk.get_file_by_path(file_path)
+                if f:
+                    file_id = f.id
+
+            # Try function first
+            funcs = sdk.get_function_by_name(symbol_name, file_id)
+            if funcs:
+                func = funcs[0]
+                if len(funcs) > 1:
+                    impls = [m for m in funcs if m.parent_type == 'class']
+                    if impls:
+                        func = impls[0]
+                source = sdk._read_source_lines(func.file_id, func.location.start_line, func.location.end_line)
+                if source is not None:
+                    return {
+                        "file_path": func.file_path,
+                        "start_line": func.location.start_line,
+                        "end_line": func.location.end_line,
+                        "source": source,
+                        "kind": "function",
+                    }
+
+            # Try class
+            classes = sdk.get_class_by_name(symbol_name, file_id)
+            if classes:
+                cls = classes[0]
+                source = sdk._read_source_lines(cls.file_id, cls.location.start_line, cls.location.end_line)
+                if source is not None:
+                    return {
+                        "file_path": cls.file_path,
+                        "start_line": cls.location.start_line,
+                        "end_line": cls.location.end_line,
+                        "source": source,
+                        "kind": "class",
+                    }
+
+            # Try frontend entities (components, CSS selectors, custom properties)
+            frontend_result = find_frontend_by_name(symbol_name, file_path)
+            if frontend_result:
+                return frontend_result
+
+            return None
+    except Exception:
+        return None
+
+
+def find_frontend_entity_location(entity_type: str, entity_id: int):
+    """Find the file path and source range of a frontend entity by type and ID.
+
+    Args:
+        entity_type: One of "markup_element", "css_rule", "custom_property",
+                     "event_binding", "property_binding", "jsx_subtree", "component".
+        entity_id: ID of the entity in its table.
+
+    Returns:
+        dict with keys: file_path, start_line, end_line, source, kind
+        or None if not found.
+    """
+    db_path = Path.cwd() / ".raggie" / ".code_index.raggie"
+
+    if not db_path.exists():
+        return None
+
+    table_map = {
+        "markup_element": "markup_elements",
+        "jsx_subtree": "markup_elements",
+        "css_rule": "style_selectors",
+        "custom_property": "style_custom_properties",
+        "event_binding": "frontend_events",
+        "property_binding": "frontend_bindings",
+        "component": "frontend_components",
+    }
+
+    table = table_map.get(entity_type)
+    if not table:
+        return None
+
+    try:
+        with CodeIndexSDK(str(db_path)) as sdk:
+            import json as _json
+            row = sdk.conn.execute(
+                f"""SELECT m.*, f.path as file_path
+                    FROM {table} m
+                    JOIN files f ON m.file_id = f.id
+                    WHERE m.id = ?""",
+                (entity_id,)
+            ).fetchone()
+            if not row:
+                return None
+
+            sr = _json.loads(row["source_range"]) if row["source_range"] else None
+            if not sr:
+                return None
+
+            start_line = sr.get("start_line", 1)
+            end_line = sr.get("end_line", start_line)
+
+            source = sdk._read_source_lines(row["file_id"], start_line, end_line)
+
+            return {
+                "file_path": row["file_path"],
+                "start_line": start_line,
+                "end_line": end_line,
+                "source": source,
+                "kind": entity_type,
+            }
+    except Exception:
+        return None
+
+
+def find_frontend_by_name(name: str, file_path: str = None):
+    """Find a frontend entity by name (component name, selector text, etc.).
+
+    Args:
+        name: Component name, selector text, or custom property name.
+        file_path: Optional file path to disambiguate.
+
+    Returns:
+        dict with keys: file_path, start_line, end_line, source, kind, entity_type, entity_id
+        or None if not found.
+    """
+    db_path = Path.cwd() / ".raggie" / ".code_index.raggie"
+
+    if not db_path.exists():
+        return None
+
+    try:
+        with CodeIndexSDK(str(db_path)) as sdk:
+            import json as _json
+            conn = sdk.conn
+            file_id = None
+            if file_path:
+                f = sdk.get_file_by_path(file_path)
+                if f:
+                    file_id = f.id
+
+            # Try component name
+            if file_id:
+                row = conn.execute(
+                    """SELECT c.*, f.path as file_path
+                       FROM frontend_components c
+                       JOIN files f ON c.file_id = f.id
+                       WHERE c.name = ? AND c.file_id = ?
+                       LIMIT 1""",
+                    (name, file_id)
+                ).fetchone()
+            else:
+                row = conn.execute(
+                    """SELECT c.*, f.path as file_path
+                       FROM frontend_components c
+                       JOIN files f ON c.file_id = f.id
+                       WHERE c.name = ?
+                       LIMIT 1""",
+                    (name,)
+                ).fetchone()
+
+            if row:
+                sr = _json.loads(row["source_range"]) if row["source_range"] else None
+                start_line = sr.get("start_line", 1) if sr else 1
+                end_line = sr.get("end_line", start_line) if sr else start_line
+                source = sdk._read_source_lines(row["file_id"], start_line, end_line)
+                return {
+                    "file_path": row["file_path"],
+                    "start_line": start_line,
+                    "end_line": end_line,
+                    "source": source,
+                    "kind": "component",
+                    "entity_type": "component",
+                    "entity_id": row["id"],
+                }
+
+            # Try selector text
+            if file_id:
+                row = conn.execute(
+                    """SELECT s.*, f.path as file_path
+                       FROM style_selectors s
+                       JOIN files f ON s.file_id = f.id
+                       WHERE s.selector_text = ? AND s.file_id = ?
+                       LIMIT 1""",
+                    (name, file_id)
+                ).fetchone()
+            else:
+                row = conn.execute(
+                    """SELECT s.*, f.path as file_path
+                       FROM style_selectors s
+                       JOIN files f ON s.file_id = f.id
+                       WHERE s.selector_text = ?
+                       LIMIT 1""",
+                    (name,)
+                ).fetchone()
+
+            if row:
+                sr = _json.loads(row["source_range"]) if row["source_range"] else None
+                start_line = sr.get("start_line", 1) if sr else 1
+                end_line = sr.get("end_line", start_line) if sr else start_line
+                source = sdk._read_source_lines(row["file_id"], start_line, end_line)
+                return {
+                    "file_path": row["file_path"],
+                    "start_line": start_line,
+                    "end_line": end_line,
+                    "source": source,
+                    "kind": "css_rule",
+                    "entity_type": "css_rule",
+                    "entity_id": row["id"],
+                }
+
+            # Try custom property name
+            if file_id:
+                row = conn.execute(
+                    """SELECT cp.*, f.path as file_path
+                       FROM style_custom_properties cp
+                       JOIN files f ON cp.file_id = f.id
+                       WHERE cp.name = ? AND cp.file_id = ?
+                       LIMIT 1""",
+                    (name, file_id)
+                ).fetchone()
+            else:
+                row = conn.execute(
+                    """SELECT cp.*, f.path as file_path
+                       FROM style_custom_properties cp
+                       JOIN files f ON cp.file_id = f.id
+                       WHERE cp.name = ?
+                       LIMIT 1""",
+                    (name,)
+                ).fetchone()
+
+            if row:
+                sr = _json.loads(row["source_range"]) if row["source_range"] else None
+                start_line = sr.get("start_line", 1) if sr else 1
+                end_line = sr.get("end_line", start_line) if sr else start_line
+                source = sdk._read_source_lines(row["file_id"], start_line, end_line)
+                return {
+                    "file_path": row["file_path"],
+                    "start_line": start_line,
+                    "end_line": end_line,
+                    "source": source,
+                    "kind": "custom_property",
+                    "entity_type": "custom_property",
+                    "entity_id": row["id"],
+                }
+
+            return None
+    except Exception:
+        return None
+
+
+def find_frontend_entity(entity_type: str, name: str, file_path: str = None):
+    """Find a frontend entity by type and name.
+
+    Args:
+        entity_type: One of "component", "css_rule", "custom_property",
+                     "markup_element", "event_binding", "property_binding".
+        name: Component name, selector text, custom property name, or tag name.
+        file_path: Optional file path to disambiguate.
+
+    Returns:
+        dict with keys: file_path, start_line, end_line, source, kind, entity_type, entity_id
+        or None if not found.
+    """
+    if entity_type == "component":
+        return find_frontend_by_name(name, file_path)
+    if entity_type == "css_rule":
+        return find_frontend_by_name(name, file_path)
+    if entity_type == "custom_property":
+        return find_frontend_by_name(name, file_path)
+    # For markup_element, event_binding, property_binding — search by name in respective tables
+    return find_frontend_by_name(name, file_path)
+
+
+def find_symbol_implementation(symbol_name: str, file_path: str = None) -> str:
+    """Find and return the source implementation of a symbol (function or class).
+
+    Args:
+        symbol_name: Name of the symbol to find
+        file_path: Optional file path to disambiguate same-name symbols
+
+    Returns:
+        Source code string of the symbol, or error message if not found
+    """
+    db_path = Path.cwd() / ".raggie" / ".code_index.raggie"
+    
+    if not db_path.exists():
+        return f"Error: Code index database not found at {db_path}"
+    
+    try:
+        with CodeIndexSDK(str(db_path)) as sdk:
+            # Try to find as function first
+            func_body = sdk.get_function_body(symbol_name, file_path)
+            if func_body:
+                return func_body
+            
+            # Try to find as class
+            class_body = sdk.get_class_body(symbol_name, file_path)
+            if class_body:
+                return class_body
+            
+            # Search for similar symbols by name and description
+            matches = sdk.search_symbols(symbol_name, limit=10)
+            
+            if matches:
+                lines = [f"Symbol '{symbol_name}' not found by exact name. Similar symbols:"]
+                for m in matches:
+                    desc_suffix = f" — {m['description']}" if m.get('description') else ""
+                    lines.append(f"  - {m['type']}: {m['name']} in {m['file_path']} ({m['match_reason']}){desc_suffix}")
+                return "\n".join(lines)
+            
+            return f"Error: Symbol '{symbol_name}' not found in code index."
+    except Exception as e:
+        return f"Error querying code index: {str(e)}"

RAG/graph.py

@@ -0,0 +1,231 @@
+import json
+from pathlib import Path
+
+from indexing.code_index_sdk import CodeIndexSDK
+
+
+def explore_code_structure(file_path: str, include_bodies: bool = False) -> str:
+    """Explore the code structure and dependencies of a file.
+
+    Args:
+        file_path: Path to the file to analyze
+        include_bodies: If True, include full source code for all functions and classes in the file
+
+    Returns:
+        YAML-like formatted string showing the dependency graph, optionally with symbol bodies.
+        For frontend files (HTML, CSS, JSX, TSX), returns structured semantic output instead.
+    """
+    db_path = Path.cwd() / ".raggie" / ".code_index.raggie"
+
+    if not db_path.exists():
+        return f"Error: Code index database not found at {db_path}"
+
+    try:
+        with CodeIndexSDK(str(db_path)) as sdk:
+            # Check if this is a frontend file
+            from indexing.frontend.semantic_output import format_file_semantics
+            semantic = format_file_semantics(sdk.conn, file_path)
+            if semantic is not None:
+                # Frontend file — return semantic output
+                if include_bodies:
+                    # Append raw source when bodies are explicitly requested
+                    normalized = file_path[2:] if file_path.startswith('./') else file_path
+                    file = sdk.get_file_by_path(normalized)
+                    if file:
+                        raw = sdk._read_source_lines(file.id, 1, 0) if hasattr(sdk, '_read_source_lines') else ""
+                        if raw:
+                            return semantic + "\n\n## Raw Source\n" + raw
+                return semantic
+
+            graph = sdk.get_dependency_graph(file_path)
+
+            if not include_bodies:
+                return graph
+
+            # Get the file to fetch all symbols
+            file = sdk.get_file_by_path(file_path)
+            if not file:
+                # Fallback: try matching by filename (same logic as get_dependency_graph)
+                from pathlib import Path as _Path
+                filename = _Path(file_path[2:] if file_path.startswith('./') else file_path).name
+                cursor = sdk.conn.cursor()
+                cursor.execute("SELECT * FROM files WHERE path LIKE ?", (f"%{filename}",))
+                row = cursor.fetchone()
+                if row:
+                    from indexing.models import File
+                    file = File.from_row(row)
+            if not file:
+                return graph
+
+            # Get all functions and classes in the file
+            functions = sdk.get_file_functions(file.id)
+            classes = sdk.get_file_classes(file.id)
+
+            # Build the bodies section
+            bodies_section = []
+            if functions:
+                bodies_section.append("\n## Function Bodies")
+                for func in functions:
+                    body = sdk._read_source_lines(func.file_id, func.location.start_line, func.location.end_line)
+                    desc = f"# Description: {func.description}\n\n" if func.description else ""
+                    bodies_section.append(f"\n### {func.name}\n{desc}{body}")
+
+            if classes:
+                bodies_section.append("\n## Class Bodies")
+                for cls in classes:
+                    body = sdk._read_source_lines(cls.file_id, cls.location.start_line, cls.location.end_line)
+                    desc = f"# Description: {cls.description}\n\n" if cls.description else ""
+                    bodies_section.append(f"\n### {cls.name}\n{desc}{body}")
+
+            if bodies_section:
+                return graph + "\n" + "".join(bodies_section)
+
+            return graph
+    except Exception as e:
+        return f"Error querying code index: {str(e)}"
+
+
+def walk_call_tree(symbol_name: str, file_path: str = None,
+                   max_depth: int = 5, include_external: bool = False,
+                   exclude: list = None) -> str:
+    """Walk the call tree starting from a function/method, depth-limited with cycle detection.
+
+    Args:
+        symbol_name: Name of the starting function/method.
+        file_path: Optional file path to disambiguate same-name symbols.
+        max_depth: Maximum depth to traverse (default 5).
+        include_external: If True, include external/third-party calls.
+        exclude: Optional list of path prefixes to exclude (e.g. ["tests/"]).
+
+    Returns:
+        JSON lines string, one object per node, sorted by depth then name.
+    """
+    db_path = Path.cwd() / ".raggie" / ".code_index.raggie"
+
+    if not db_path.exists():
+        return json.dumps({"error": f"Code index database not found at {db_path}"})
+
+    try:
+        with CodeIndexSDK(str(db_path)) as sdk:
+            return sdk.walk_call_tree(symbol_name, file_path, max_depth, include_external, exclude)
+    except Exception as e:
+        return json.dumps({"error": f"Error walking call tree: {str(e)}"})
+
+
+def explore_frontend_structure(file_path: str) -> str:
+    """Explore the frontend structure of a file (components, markup, styles, events).
+
+    Args:
+        file_path: Path to the frontend file (TSX, HTML, CSS).
+
+    Returns:
+        JSON string with component info, markup trees, events, bindings, and styles.
+    """
+    db_path = Path.cwd() / ".raggie" / ".code_index.raggie"
+
+    if not db_path.exists():
+        return json.dumps({"error": f"Code index database not found at {db_path}"})
+
+    try:
+        with CodeIndexSDK(str(db_path)) as sdk:
+            file = sdk.get_file_by_path(file_path)
+            if not file:
+                from pathlib import Path as _Path
+                filename = _Path(file_path[2:] if file_path.startswith('./') else file_path).name
+                cursor = sdk.conn.cursor()
+                cursor.execute("SELECT * FROM files WHERE path LIKE ?", (f"%{filename}",))
+                row = cursor.fetchone()
+                if row:
+                    from indexing.models import File
+                    file = File.from_row(row)
+            if not file:
+                return json.dumps({"error": f"File not found: {file_path}"})
+
+            cursor = sdk.conn.cursor()
+
+            # Get components in this file
+            cursor.execute(
+                "SELECT id, name, framework, is_exported FROM frontend_components WHERE file_id = ?",
+                (file.id,)
+            )
+            components = [dict(row) for row in cursor.fetchall()]
+
+            result = {
+                "file_path": file_path,
+                "components": [],
+            }
+
+            for comp in components:
+                traversal = sdk.traverse_full_frontend(comp["id"])
+                result["components"].append(traversal)
+
+            # If no components, try markup elements (HTML)
+            if not components:
+                cursor.execute(
+                    "SELECT id, tag_name, element_type FROM markup_elements WHERE file_id = ? ORDER BY id",
+                    (file.id,)
+                )
+                elements = [dict(row) for row in cursor.fetchall()]
+                if elements:
+                    result["markup_elements"] = elements
+
+                cursor.execute(
+                    "SELECT id, selector_text, selector_type FROM style_selectors WHERE file_id = ? ORDER BY id",
+                    (file.id,)
+                )
+                selectors = [dict(row) for row in cursor.fetchall()]
+                if selectors:
+                    result["style_selectors"] = selectors
+
+            return json.dumps(result, ensure_ascii=False, default=str)
+    except Exception as e:
+        return json.dumps({"error": f"Error exploring frontend structure: {str(e)}"})
+
+
+def walk_render_tree(component_name: str, file_path: str = None,
+                     max_depth: int = 10) -> str:
+    """Walk the render tree starting from a component, depth-limited with cycle detection.
+
+    Args:
+        component_name: Name of the starting component.
+        file_path: Optional file path to disambiguate same-name components.
+        max_depth: Maximum traversal depth (default 10).
+
+    Returns:
+        JSON string with the render tree (children direction).
+    """
+    db_path = Path.cwd() / ".raggie" / ".code_index.raggie"
+
+    if not db_path.exists():
+        return json.dumps({"error": f"Code index database not found at {db_path}"})
+
+    try:
+        with CodeIndexSDK(str(db_path)) as sdk:
+            cursor = sdk.conn.cursor()
+
+            if file_path:
+                file = sdk.get_file_by_path(file_path)
+                if file:
+                    cursor.execute(
+                        "SELECT id FROM frontend_components WHERE name = ? AND file_id = ? LIMIT 1",
+                        (component_name, file.id)
+                    )
+                else:
+                    cursor.execute(
+                        "SELECT id FROM frontend_components WHERE name = ? LIMIT 1",
+                        (component_name,)
+                    )
+            else:
+                cursor.execute(
+                    "SELECT id FROM frontend_components WHERE name = ? LIMIT 1",
+                    (component_name,)
+                )
+
+            row = cursor.fetchone()
+            if not row:
+                return json.dumps({"error": f"Component not found: {component_name}"})
+
+            result = sdk.traverse_render_graph(row["id"], "children", max_depth)
+            return json.dumps(result, ensure_ascii=False, default=str)
+    except Exception as e:
+        return json.dumps({"error": f"Error walking render tree: {str(e)}"})

Tools/GetFileCodeStructure.py

@@ -0,0 +1,43 @@
+from pathlib import Path
+
+from RAG.graph import explore_code_structure
+from .utils import is_within_cwd, BLUE, RESET
+
+
+def handle(arguments, toolcall_id):
+    file_path = arguments["file_path"]
+    include_bodies = arguments.get("include_bodies", False)
+    print(f"{BLUE}GetFileCodeSemantics {file_path}{RESET}")
+
+    # Check if the file is outside the current working directory
+    if not is_within_cwd(file_path):
+        return {
+            "role": "tool",
+            "tool_call_id": toolcall_id,
+            "content": "Error: access denied - path is outside the current working directory",
+        }
+
+    try:
+        path = Path(file_path)
+        if path.is_dir():
+            entries = sorted(path.iterdir(), key=lambda p: (not p.is_dir(), p.name.lower()))
+            lines = [f"Contents of {file_path} ({len(entries)} items):"]
+            for entry in entries:
+                if entry.is_dir():
+                    lines.append(f"  [DIR]  {entry.name}/")
+                else:
+                    lines.append(f"  [FILE] {entry.name}")
+            result = "\n".join(lines)
+        else:
+            result = explore_code_structure(file_path, include_bodies=include_bodies)
+            if result.startswith("Error: File not found in database"):
+                with open(file_path, "r") as f:
+                    result = f.read()
+    except Exception as e:
+        result = f"Error exploring code structure: {str(e)}"
+
+    return {
+        "role": "tool",
+        "tool_call_id": toolcall_id,
+        "content": result,
+    }