raggiecode 0.2.1__py3-none-any.whl

Tools/GetSymbolSourceCode.py

@@ -0,0 +1,27 @@
+from RAG.find import find_symbol_implementation
+from .utils import is_within_cwd, BLUE, RESET
+
+
+def handle(arguments, toolcall_id):
+    symbol_name = arguments["symbol_name"]
+    file_path = arguments.get("file_path")
+    print(f"{BLUE}GetSymbolSourceCode {symbol_name}{RESET}")
+
+    # Check if the file is outside the current working directory
+    if file_path and 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:
+        result = find_symbol_implementation(symbol_name, file_path)
+    except Exception as e:
+        result = f"Error finding symbol implementation: {str(e)}"
+    
+    return {
+        "role": "tool",
+        "tool_call_id": toolcall_id,
+        "content": result,
+    }

Tools/__init__.py

@@ -0,0 +1,39 @@
+from Agent.tools import ToolRegistry
+
+def setup_toolcalls(registry: ToolRegistry):
+    from . import shell, temp_background_service, shell_kill, read, write, replace, remove, GetSymbolSourceCode, GetFileCodeStructure, document, walk_call_tree, list_dir, search, fuzzy_search, read_image, dispatch_subagent, todo_list, web_fetch, web_search, view_changes, ask_user, edit_symbol
+    from skills.tool import handle as update_skill_handle
+    from skills.tool import handle_get_skill as get_skill_handle
+
+    registry.set_handler("UglyWholeFileContentDump", read.handle)
+    registry.set_handler("SearchAllFilesContent", search.handle)
+    registry.set_handler("FileNameSearch", fuzzy_search.handle)
+    registry.set_handler("ListDir", list_dir.handle)
+    registry.set_handler("WriteFile", write.handle)
+    registry.set_handler("Shell", shell.handle)
+    registry.set_handler("TempBackgroundService", temp_background_service.handle)
+    registry.set_handler("ShellKill", shell_kill.handle)
+    registry.set_handler("ReplaceText", replace.handle)
+    registry.set_handler("RemoveFile", remove.handle)
+    registry.set_handler("GetSymbolSourceCode", GetSymbolSourceCode.handle)
+    registry.set_handler("GetFileCodeSemantics", GetFileCodeStructure.handle)
+    registry.set_handler("WalkCallTree", walk_call_tree.handle)
+    registry.set_handler("Document", document.handle)
+    registry.set_handler("SetSkill", update_skill_handle)
+    registry.set_handler("GetSkill", get_skill_handle)
+    registry.set_handler("ReadImage", read_image.handle)
+    registry.set_handler("WebFetch", web_fetch.handle)
+    registry.set_handler("WebSearch", web_search.handle)
+    registry.set_handler("DispatchSubagent", dispatch_subagent.handle)
+    registry.set_handler("CreateTodoList", todo_list.handle_create_todo_list)
+    registry.set_handler("AddTask", todo_list.handle_add_task)
+    registry.set_handler("GetTodoList", todo_list.handle_get_todo_list)
+    registry.set_handler("ApproveTodoList", todo_list.handle_approve_todo_list)
+    registry.set_handler("ExecuteNextTask", todo_list.handle_execute_next_task)
+    registry.set_handler("MarkTaskComplete", todo_list.handle_mark_task_complete)
+    registry.set_handler("MarkTaskFailed", todo_list.handle_mark_task_failed)
+    registry.set_handler("MarkTaskCancelled", todo_list.handle_mark_task_cancelled)
+    registry.set_handler("GetActiveTodoList", todo_list.handle_get_active_todo_list)
+    registry.set_handler("AskUser", ask_user.handle)
+    registry.set_handler("ViewChanges", view_changes.handle)
+    registry.set_handler("EditSymbol", edit_symbol.handle)

Tools/ask_user.py

@@ -0,0 +1,102 @@
+from .utils import BLUE, GREEN, YELLOW, RED, RESET
+
+
+def handle(arguments, toolcall_id):
+    """Ask the user a question, optionally with predefined options."""
+    from prompt_toolkit import prompt
+
+    question = arguments.get("question", "")
+    options = arguments.get("options", [])
+    allow_multiple = arguments.get("allow_multiple", False)
+
+    if not question:
+        return {
+            "role": "tool",
+            "tool_call_id": toolcall_id,
+            "content": "Error: 'question' is required",
+        }
+
+    try:
+        print(f"\n{BLUE}Agent has a question:{RESET}")
+        print(f"{YELLOW}{question}{RESET}")
+        print()
+
+        if not options:
+            # Free-form question
+            user_input = prompt("Your answer: ", multiline=True).strip()
+            print()
+            return {
+                "role": "tool",
+                "tool_call_id": toolcall_id,
+                "content": f"User answered: {user_input}",
+            }
+
+        # Display numbered options
+        print(f"{BLUE}Options:{RESET}")
+        for i, opt in enumerate(options):
+            label = opt.get("label", f"Option {i + 1}")
+            description = opt.get("description", "")
+            print(f"  {GREEN}{i + 1}.{RESET} {label}")
+            if description:
+                print(f"     {description}")
+        print()
+
+        if allow_multiple:
+            hint = "Enter one or more numbers (comma-separated), or type your own answer"
+        else:
+            hint = "Enter a number, or type your own answer"
+
+        user_input = prompt(f"{hint}: ", multiline=True).strip()
+        print()
+
+        if not user_input:
+            return {
+                "role": "tool",
+                "tool_call_id": toolcall_id,
+                "content": "User skipped the question (no answer provided)",
+            }
+
+        # Try to parse as number(s)
+        selected_labels = []
+        try:
+            if allow_multiple:
+                indices = [int(x.strip()) for x in user_input.split(",")]
+                for idx in indices:
+                    if 1 <= idx <= len(options):
+                        selected_labels.append(options[idx - 1].get("label", f"Option {idx}"))
+                    else:
+                        selected_labels.append(f"(invalid: {idx})")
+            else:
+                idx = int(user_input)
+                if 1 <= idx <= len(options):
+                    selected_labels.append(options[idx - 1].get("label", f"Option {idx}"))
+                else:
+                    selected_labels.append(f"(invalid: {idx})")
+            answer = ", ".join(selected_labels)
+            print(f"{GREEN}User selected: {answer}{RESET}\n")
+            return {
+                "role": "tool",
+                "tool_call_id": toolcall_id,
+                "content": f"User selected: {answer}",
+            }
+        except ValueError:
+            # User typed a custom answer
+            print(f"{GREEN}User answered: {user_input}{RESET}\n")
+            return {
+                "role": "tool",
+                "tool_call_id": toolcall_id,
+                "content": f"User answered: {user_input}",
+            }
+    except (KeyboardInterrupt, EOFError):
+        print(f"\n{RED}User cancelled the question{RESET}\n")
+        return {
+            "role": "tool",
+            "tool_call_id": toolcall_id,
+            "content": "User cancelled the question (Ctrl+C)",
+        }
+    except Exception as e:
+        return {
+            "role": "tool",
+            "tool_call_id": toolcall_id,
+            "content": f"Failed to ask user: {str(e)}",
+        }

Tools/dispatch_subagent.py

@@ -0,0 +1,215 @@
+from .utils import BLUE, RESET
+
+
+def _get_session_depth(session_id: int) -> int:
+    """Calculate the depth of a session in the subagent hierarchy by traversing parent_session_id."""
+    import sqlite3
+    from pathlib import Path
+    
+    DB_PATH = Path(".raggie/.raggie.chat")
+    depth = 0
+    current_id = session_id
+    visited = set()
+    
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    
+    try:
+        while current_id is not None and current_id not in visited:
+            visited.add(current_id)
+            cursor.execute("""
+                SELECT parent_session_id FROM sessions WHERE id = ?
+            """, (current_id,))
+            result = cursor.fetchone()
+            if result and result[0] is not None:
+                current_id = result[0]
+                depth += 1
+            else:
+                break
+    finally:
+        conn.close()
+    
+    return depth
+
+
+def _collect_subagent_output(subagent, subagent_session_id, prompt=None, resume=False):
+    """Run a subagent and collect its output. If resume=True, resume dangling work instead of starting fresh."""
+    output_parts = []
+    error_occurred = False
+
+    try:
+        if resume:
+            events = subagent.resume_dangling_tool_work()
+        else:
+            events = subagent.start(prompt=prompt)
+
+        if events is None:
+            events = []
+
+        for event_type, *event_data in events:
+            if event_type == "response":
+                output_parts.append(event_data[0])
+            elif event_type == "response_end":
+                output_parts.append(event_data[0])
+            elif event_type == "error":
+                output_parts.append(f"Error: {event_data[0]}")
+                error_occurred = True
+                break
+    except Exception as e:
+        output_parts.append(f"Subagent execution failed: {str(e)}")
+        error_occurred = True
+
+    output = "\n".join(output_parts) if output_parts else "No output from subagent"
+
+    if error_occurred:
+        output = f"Subagent encountered errors:\n{output}"
+
+    from Agent.chat_history_db import get_all_changes_by_session_chain
+    changes = get_all_changes_by_session_chain(subagent_session_id)
+    if changes:
+        changes_summary = "\n".join(
+            f"  - [{c['change_type']}] {c['file_path'] or 'N/A'}: {c['description']}"
+            for c in changes
+        )
+        output = f"{output}\n\n--- Changes made by subagent for you to review ---\n{changes_summary}"
+
+    return output
+
+
+def handle(arguments, toolcall_id, parent_session_id=None, skip_depth_check=False):
+    prompt = arguments.get("prompt")
+
+    if not prompt:
+        return {
+            "role": "tool",
+            "tool_call_id": toolcall_id,
+            "content": "Error: 'prompt' is a required parameter",
+        }
+
+    if parent_session_id is None:
+        return {
+            "role": "tool",
+            "tool_call_id": toolcall_id,
+            "content": "Error: parent_session_id is required to determine the subagent role",
+        }
+
+    from Agent.chat_history_db import get_session_role, get_session_effort, get_session_depth
+    from Agent.effort_levels import is_depth_allowed, effort_name, effort_max_depth
+    role = get_session_role(parent_session_id)
+    if not role:
+        return {
+            "role": "tool",
+            "tool_call_id": toolcall_id,
+            "content": f"Error: Could not determine role for parent session {parent_session_id}",
+        }
+
+    # Check depth limit via the effort system
+    if not skip_depth_check:
+        effort = get_session_effort(parent_session_id)
+        depth = get_session_depth(parent_session_id)
+        if effort is not None and not is_depth_allowed(effort, depth):
+            max_d = effort_max_depth(effort)
+            return {
+                "role": "tool",
+                "tool_call_id": toolcall_id,
+                "content": f"Cannot dispatch subagent: effort level '{effort_name(effort)}' limits depth to {max_d}. Current depth is {depth}.",
+            }
+
+    try:
+        from Agent.chat_history_db import (
+            get_chat_id_for_session, create_session, get_child_session_by_toolcall,
+            is_session_finished, load_messages,
+            get_session_effort, get_session_depth,
+            resolve_session_id,
+        )
+        from Agent.agent import Agent
+        from Tools import setup_toolcalls
+        from Commands import setup_commands
+
+        chat_id = get_chat_id_for_session(parent_session_id)
+        if chat_id is None:
+            return {
+                "role": "tool",
+                "tool_call_id": toolcall_id,
+                "content": f"Error: Could not find chat for parent session {parent_session_id}",
+            }
+
+        # Check for existing child session matching this toolcall_id (from a previous interrupted dispatch)
+        child = get_child_session_by_toolcall(parent_session_id, toolcall_id)
+        if child is not None:
+            child_session_id = child["id"]
+            # Follow redirect chain to find the active session (may have been handed over)
+            active_session_id = resolve_session_id(child_session_id)
+            if is_session_finished(child_session_id):
+                # Subagent completed but main agent was interrupted before processing the result
+                print(f"{BLUE}Found completed subagent session {active_session_id}, retrieving output...{RESET}")
+                messages = load_messages(active_session_id)
+                output_parts = []
+                for msg in messages:
+                    if msg.get("role") == "assistant" and not msg.get("tool_calls"):
+                        output_parts.append(msg.get("content", ""))
+                output = "\n".join(output_parts) if output_parts else "No output from subagent"
+
+                from Agent.chat_history_db import get_all_changes_by_session_chain
+                changes = get_all_changes_by_session_chain(active_session_id)
+                if changes:
+                    changes_summary = "\n".join(
+                        f"  - [{c['change_type']}] {c['file_path'] or 'N/A'}: {c['description']}"
+                        for c in changes
+                    )
+                    output = f"{output}\n\n--- Changes made by subagent for you to review ---\n{changes_summary}"
+
+                return {
+                    "role": "tool",
+                    "tool_call_id": toolcall_id,
+                    "content": output,
+                    "subagent_session_id": active_session_id,
+                }
+            else:
+                # Subagent was interrupted — resume it
+                print(f"{BLUE}Resuming interrupted subagent session {active_session_id}...{RESET}")
+                subagent = Agent(role=role, chat_id=chat_id, session_id=active_session_id)
+                setup_toolcalls(subagent.tool_registry)
+                setup_commands(subagent.command_registry)
+
+                output = _collect_subagent_output(
+                    subagent, active_session_id, resume=True
+                )
+
+                return {
+                    "role": "tool",
+                    "tool_call_id": toolcall_id,
+                    "content": output,
+                    "subagent_session_id": active_session_id,
+                }
+
+        # No existing child session — create a new one under the parent's chat
+        print(f"{BLUE}Dispatching subagent with role '{role}'{RESET}")
+        parent_effort = get_session_effort(parent_session_id)
+        parent_depth = get_session_depth(parent_session_id)
+        subagent_session_id = create_session(
+            chat_id, parent_session_id=parent_session_id, toolcall_id=toolcall_id,
+            effort=parent_effort, depth=parent_depth + 1,
+        )
+
+        subagent = Agent(role=role, chat_id=chat_id, session_id=subagent_session_id)
+        setup_toolcalls(subagent.tool_registry)
+        setup_commands(subagent.command_registry)
+
+        output = _collect_subagent_output(
+            subagent, subagent_session_id, prompt=prompt, resume=False
+        )
+
+        return {
+            "role": "tool",
+            "tool_call_id": toolcall_id,
+            "content": output,
+            "subagent_session_id": subagent_session_id,
+        }
+
+    except Exception as e:
+        return {
+            "role": "tool",
+            "tool_call_id": toolcall_id,
+            "content": f"Failed to dispatch subagent: {str(e)}",
+        }

Tools/document.py

@@ -0,0 +1,35 @@
+from RAG.document import update_symbol_description, get_symbol_description
+from .utils import is_within_cwd, BLUE, RESET
+
+
+def handle(arguments, toolcall_id):
+    action = arguments.get("action", "update")
+    symbol_name = arguments["symbol_name"]
+    print(f"{BLUE}Document {symbol_name}{RESET}")
+    symbol_type = arguments.get("symbol_type", "function")
+    file_path = arguments.get("file_path")
+
+    # Check if the file is outside the current working directory
+    if file_path and 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:
+        if action == "read":
+            result = get_symbol_description(symbol_name, symbol_type, file_path)
+        elif action == "update":
+            description = arguments["description"]
+            result = update_symbol_description(symbol_name, description, symbol_type, file_path)
+        else:
+            result = f"Error: Unknown action '{action}'. Must be 'read' or 'update'."
+    except Exception as e:
+        result = f"Error: {str(e)}"
+    
+    return {
+        "role": "tool",
+        "tool_call_id": toolcall_id,
+        "content": result,
+    }

Tools/edit_symbol.py

@@ -0,0 +1,250 @@
+import os
+
+from RAG.find import find_symbol_location, find_frontend_entity_location
+from .utils import is_ignored_by_gitignore, is_within_cwd, BLUE, RESET, auto_record_change, reindex_after_change
+
+# Frontend entity types that can be edited via edit_safety
+_FRONTEND_ENTITY_TYPES = {
+    "markup_element", "css_rule", "custom_property",
+    "event_binding", "property_binding", "jsx_subtree",
+}
+
+
+def handle(arguments, toolcall_id, session_id=None, code_indexer=None):
+    symbol_name = arguments["symbol_name"]
+    file_path = arguments.get("file_path")
+    new_source = arguments.get("new_source")
+    entity_type = arguments.get("entity_type")
+    entity_id = arguments.get("entity_id")
+
+    print(f"{BLUE}EditSymbol {symbol_name}{RESET}")
+
+    if not new_source:
+        return {
+            "role": "tool",
+            "tool_call_id": toolcall_id,
+            "content": "Error: 'new_source' cannot be empty.",
+        }
+
+    try:
+        # Frontend entity edit path
+        if entity_type and entity_type in _FRONTEND_ENTITY_TYPES and entity_id is not None:
+            return _handle_frontend_edit(
+                entity_type, entity_id, new_source, file_path,
+                toolcall_id, session_id, code_indexer,
+            )
+
+        # Standard symbol edit path (functions, classes)
+        loc = find_symbol_location(symbol_name, file_path)
+        if loc is None:
+            hint = ""
+            if file_path:
+                hint = f" in file '{file_path}'"
+            return {
+                "role": "tool",
+                "tool_call_id": toolcall_id,
+                "content": (
+                    f"Error: Symbol '{symbol_name}' not found in code index{hint}. "
+                    "Make sure the code index is up to date and the symbol name is correct."
+                ),
+            }
+
+        resolved_path = loc["file_path"]
+        start_line = loc["start_line"]
+        end_line = loc["end_line"]
+        old_source = loc["source"]
+
+        # Security checks
+        if not is_within_cwd(resolved_path):
+            return {
+                "role": "tool",
+                "tool_call_id": toolcall_id,
+                "content": "Error: access denied - path is outside the current working directory",
+            }
+
+        if is_ignored_by_gitignore(resolved_path):
+            return {
+                "role": "tool",
+                "tool_call_id": toolcall_id,
+                "content": (
+                    f"Error: File '{resolved_path}' is in .gitignore. "
+                    "Operations on gitignored files are not allowed."
+                ),
+            }
+
+        if not os.path.exists(resolved_path):
+            return {
+                "role": "tool",
+                "tool_call_id": toolcall_id,
+                "content": f"Error: File '{resolved_path}' does not exist.",
+            }
+
+        with open(resolved_path, "r", encoding="utf-8") as f:
+            content = f.read()
+
+        lines = content.split("\n")
+
+        # Replace lines [start_line-1 : end_line] (1-indexed inclusive → 0-indexed slice)
+        old_lines = lines[start_line - 1:end_line]
+        new_lines = new_source.split("\n")
+
+        new_file_lines = lines[:start_line - 1] + new_lines + lines[end_line:]
+        new_content = "\n".join(new_file_lines)
+
+        with open(resolved_path, "w", encoding="utf-8") as f:
+            f.write(new_content)
+
+        # Build diff view
+        CONTEXT = 5
+        ctx_start = max(0, start_line - 1 - CONTEXT)
+        ctx_end = min(len(lines), end_line + CONTEXT)
+
+        diff_lines = [
+            f"@@ {resolved_path}:{start_line}-{end_line} ({len(old_lines)} lines "
+            f"-> {len(new_lines)} lines) @@",
+        ]
+
+        for i in range(ctx_start, start_line - 1):
+            diff_lines.append(f"    {lines[i]}")
+
+        for line in old_lines:
+            diff_lines.append(f"  - {line}")
+
+        for line in new_lines:
+            diff_lines.append(f"  + {line}")
+
+        for i in range(end_line, ctx_end):
+            diff_lines.append(f"    {lines[i]}")
+
+        diff_text = "\n".join(diff_lines)
+
+        if session_id is not None:
+            from Agent.chat_history_db import record_session_file
+            record_session_file(session_id, resolved_path, "edit_symbol")
+            auto_record_change(
+                session_id, resolved_path, "file_edit",
+                f"Edited symbol '{symbol_name}' in {resolved_path}: replaced lines {start_line}-{end_line}",
+                diff_text,
+            )
+
+        reindex_after_change(code_indexer)
+
+        summary = (
+            f"Replaced {loc['kind']} '{symbol_name}' in {resolved_path} "
+            f"(lines {start_line}-{end_line} -> {len(new_lines)} lines):\n\n"
+            f"{diff_text}"
+        )
+
+        return {
+            "role": "tool",
+            "tool_call_id": toolcall_id,
+            "content": summary,
+        }
+
+    except Exception as e:
+        return {
+            "role": "tool",
+            "tool_call_id": toolcall_id,
+            "content": f"Error executing edit_symbol: {str(e)}",
+        }
+
+
+def _handle_frontend_edit(entity_type, entity_id, new_source, file_path,
+                          toolcall_id, session_id, code_indexer):
+    """Handle editing of frontend semantic entities via edit_safety."""
+    from pathlib import Path
+    from indexing.frontend.edit_safety import validate_edit_range, apply_frontend_edit
+
+    db_path = Path.cwd() / ".raggie" / ".code_index.raggie"
+    if not db_path.exists():
+        return {
+            "role": "tool",
+            "tool_call_id": toolcall_id,
+            "content": f"Error: Code index database not found at {db_path}",
+        }
+
+    import sqlite3
+    conn = sqlite3.connect(str(db_path))
+    conn.row_factory = sqlite3.Row
+
+    try:
+        # Resolve file_path if not provided
+        if not file_path:
+            loc = find_frontend_entity_location(entity_type, entity_id)
+            if loc is None:
+                return {
+                    "role": "tool",
+                    "tool_call_id": toolcall_id,
+                    "content": f"Error: Could not resolve file path for {entity_type}#{entity_id}",
+                }
+            file_path = loc["file_path"]
+
+        # Security checks
+        resolved = file_path
+        if not os.path.isabs(resolved):
+            for base in [os.getcwd(), os.path.join(os.getcwd(), "src")]:
+                candidate = os.path.join(base, resolved)
+                if os.path.exists(candidate):
+                    resolved = candidate
+                    break
+
+        if not is_within_cwd(resolved):
+            return {
+                "role": "tool",
+                "tool_call_id": toolcall_id,
+                "content": "Error: access denied - path is outside the current working directory",
+            }
+
+        if is_ignored_by_gitignore(resolved):
+            return {
+                "role": "tool",
+                "tool_call_id": toolcall_id,
+                "content": (
+                    f"Error: File '{resolved}' is in .gitignore. "
+                    "Operations on gitignored files are not allowed."
+                ),
+            }
+
+        # Apply the edit
+        result = apply_frontend_edit(conn, entity_type, entity_id, new_source, file_path)
+
+        if not result.success:
+            return {
+                "role": "tool",
+                "tool_call_id": toolcall_id,
+                "content": f"Error: Edit rejected: {result.reason}",
+            }
+
+        # Record the change
+        if session_id is not None:
+            from Agent.chat_history_db import record_session_file
+            record_session_file(session_id, result.file_path, "edit_symbol")
+            auto_record_change(
+                session_id, result.file_path, "file_edit",
+                f"Edited {entity_type}#{entity_id} in {result.file_path}",
+                result.diff,
+            )
+
+        # Reindex
+        reindex_after_change(code_indexer)
+
+        summary = (
+            f"Replaced {entity_type}#{entity_id} in {result.file_path} "
+            f"(lines {result.source_range['start_line']}-{result.source_range['end_line']}):\n\n"
+            f"{result.diff}"
+        )
+
+        return {
+            "role": "tool",
+            "tool_call_id": toolcall_id,
+            "content": summary,
+        }
+
+    except Exception as e:
+        return {
+            "role": "tool",
+            "tool_call_id": toolcall_id,
+            "content": f"Error executing frontend edit: {str(e)}",
+        }
+    finally:
+        conn.close()