raggiecode 0.2.1__py3-none-any.whl

Agent/tools.py

@@ -0,0 +1,35 @@
+import inspect
+
+
+class ToolRegistry:
+
+    def __init__(self):
+        self.tools = {}
+        self.agent_role = None
+        self.code_indexer = None
+
+    def set_handler(self, name, callback):
+        self.tools[name] = callback
+
+    def call(self, name, arguments, toolcall_id, parent_session_id=None):
+        if name not in self.tools:
+            raise KeyError(f"Tool '{name}' is not registered")
+
+        tool = self.tools[name]
+        signature = inspect.signature(tool)
+        params = signature.parameters
+        has_agent_role = "agent_role" in params
+        has_parent_session_id = "parent_session_id" in params
+
+        kwargs = {}
+        if "code_indexer" in params:
+            kwargs["code_indexer"] = self.code_indexer
+
+        if has_agent_role and has_parent_session_id:
+            return tool(arguments, toolcall_id, self.agent_role, parent_session_id, **kwargs)
+        if has_agent_role:
+            return tool(arguments, toolcall_id, self.agent_role, **kwargs)
+        if has_parent_session_id or "session_id" in params:
+            return tool(arguments, toolcall_id, parent_session_id, **kwargs)
+
+        return tool(arguments, toolcall_id, **kwargs)

Commands/__init__.py

@@ -0,0 +1,18 @@
+from Agent.command import CommandRegistry
+
+
+def setup_commands(registry: CommandRegistry):
+    """Register all user-facing commands with the registry."""
+    from . import undo, redo, shell, stream, reasoning, window_size, help, global_todo, effort, unlimited_effort, reindex
+
+    registry.register("/undo", undo.handle)
+    registry.register("/redo", redo.handle)
+    registry.register("!", shell.handle)
+    registry.register("/streaming", stream.handle)
+    registry.register("/reasoning", reasoning.handle)
+    registry.register("/windowSize", window_size.handle)
+    registry.register("/help", help.handle)
+    registry.register("/globalTodo", global_todo.handle)
+    registry.register("/effort", effort.handle)
+    registry.register("/unlimitedEffort", unlimited_effort.handle)
+    registry.register("/reindex", reindex.handle)

Commands/effort.py

@@ -0,0 +1,42 @@
+def handle(args, agent):
+    """Set or show the effort level for the current session.
+
+    Usage:
+      /effort            Show current effort level and available options
+      /effort <num>      Set effort by number (1-5)
+      /effort <name>     Set effort by name (zen, serious, extreme, feral, insane)
+    """
+    from Agent.effort_levels import EFFORT_LEVELS, effort_name
+    from Agent.chat_history_db import get_session_effort, set_session_effort
+
+    arg = args.strip()
+
+    if not arg:
+        from interactive import _prompt_effort
+        _prompt_effort(agent.session_id)
+        return ""
+
+    # Try numeric match
+    try:
+        effort = int(arg)
+    except ValueError:
+        # Try name match (case-insensitive)
+        lower = arg.lower()
+        for num, info in EFFORT_LEVELS.items():
+            if info["name"].lower() == lower:
+                effort = num
+                break
+        else:
+            print(f"Unknown effort level: {arg}")
+            print(f"Available: {', '.join(info['name'] for info in EFFORT_LEVELS.values())}")
+            return ""
+
+    if effort not in EFFORT_LEVELS:
+        print(f"Invalid effort level: {effort}")
+        print(f"Pick a number between 1 and {len(EFFORT_LEVELS)}")
+        return ""
+
+    set_session_effort(agent.session_id, effort)
+    print(f"Effort: {EFFORT_LEVELS[effort]['name']}")
+
+    return ""

Commands/global_todo.py

@@ -0,0 +1,23 @@
+def handle(args, agent):
+    """Toggle global todo list mode on/off mid-conversation.
+
+    When enabled, todo lists are shared across all subagent sessions.
+    Usage: /globalTodo on  or  /globalTodo off
+    """
+    from Agent.config import save_roles
+
+    arg = args.strip().lower()
+
+    if arg in ("on", "true", "yes"):
+        agent.roles[agent.agent_role]["globalTodo"] = True
+        save_roles(agent.roles)
+        print("Global todo: on (saved) — todo lists are now shared across all subagent sessions")
+    elif arg in ("off", "false", "no"):
+        agent.roles[agent.agent_role]["globalTodo"] = False
+        save_roles(agent.roles)
+        print("Global todo: off (saved) — todo lists are session-scoped")
+    else:
+        state = "on" if agent.roles.get(agent.agent_role, {}).get("globalTodo", False) else "off"
+        print(f"Global todo: {state}  (usage: /globalTodo on|off)")
+
+    return ""

Commands/help.py

@@ -0,0 +1,22 @@
+def handle(args, agent):
+    """Show available in-chat commands."""
+    print()
+    print("Available commands:")
+    print()
+    print("  /undo              Undo the last agent commit")
+    print("  /redo              Re-apply the last undone commit")
+    print("  /streaming on|off  Toggle streaming mode (persists to roles.json)")
+    print("  /reasoning on|off  Toggle reasoning output (persists to roles.json)")
+    print("  /windowSize <num>  Set context window size in tokens (persists to roles.json)")
+    print("  /globalTodo on|off Toggle shared todo lists across subagents (persists to roles.json)")
+    print("  /effort <num|name> Set effort level (1-5 or zen, serious, extreme, feral, insane)")
+    print("  /reindex [--force] Re-index the codebase (use --force to re-index all files)")
+    print("  /help              Show this help message")
+    print("  !<command>         Run a shell command (e.g. !ls -la)")
+    print()
+    print("  Ctrl+C             Go back (exits too)")
+    print("  Ctrl+D             Leave the chat")
+    print()
+    print("Press Esc followed by Enter to send message, or type 'exit' to quit")
+
+    return ""

Commands/reasoning.py

@@ -0,0 +1,24 @@
+def handle(args, agent):
+    """Toggle reasoning mode on/off mid-conversation.
+
+    Usage: /reasoning on  or  /reasoning off
+    """
+    from Agent.config import save_roles
+
+    arg = args.strip().lower()
+
+    if arg in ("on", "true", "yes"):
+        agent.reasoning = True
+        agent.roles[agent.agent_role]["reasoning"] = True
+        save_roles(agent.roles)
+        print("Reasoning: on (saved)")
+    elif arg in ("off", "false", "no"):
+        agent.reasoning = False
+        agent.roles[agent.agent_role]["reasoning"] = False
+        save_roles(agent.roles)
+        print("Reasoning: off (saved)")
+    else:
+        state = "on" if agent.reasoning else "off"
+        print(f"Reasoning: {state}  (usage: /reasoning on|off)")
+
+    return ""

Commands/redo.py

@@ -0,0 +1,11 @@
+def handle(args, agent):
+    BLUE = "\033[34m"
+    RESET = "\033[0m"
+
+    redone_commit = agent.git_manager.redo_last_commit()
+    if redone_commit:
+        print(f"Redone to commit: {redone_commit}\n")
+        print(f"{BLUE}type /undo to undo the last code changes{RESET}")
+    else:
+        print("Nothing to redo")
+    return ""

Commands/reindex.py

@@ -0,0 +1,27 @@
+def handle(args, agent):
+    """Manually trigger re-indexing of the codebase.
+
+    Usage:
+      /reindex           Index new/changed files (incremental)
+      /reindex --force   Force re-index all files from scratch
+    """
+    force = "--force" in args
+
+    if agent.code_indexer is None:
+        print("No code indexer available.")
+        return ""
+
+    try:
+        if force:
+            print("Force re-indexing all files...")
+        else:
+            print("Re-indexing changed files...")
+        agent.code_indexer.index_directory(force_reindex=force)
+        print("Indexing complete.")
+    except (KeyboardInterrupt, EOFError):
+        print("\nRe-indexing interrupted.")
+        agent.code_indexer._connect()
+    except Exception as e:
+        print(f"Re-indexing failed: {e}")
+
+    return ""

Commands/shell.py

@@ -0,0 +1,28 @@
+import subprocess
+
+
+def handle(args, agent):
+    """Handle the ! shell command.
+
+    Runs *args* as a shell command and returns the combined output.
+
+    Args:
+        args: The shell command string (everything after ``!``).
+        agent: The Agent instance (unused).
+
+    Returns:
+        Empty string (agent does nothing; output is printed directly).
+    """
+    if not args:
+        return ""
+    try:
+        result = subprocess.run(
+            args, shell=True, capture_output=True, text=True
+        )
+        if result.stdout:
+            print(result.stdout)
+        if result.stderr:
+            print(result.stderr)
+    except Exception as e:
+        print(f"Error executing command: {e}")
+    return ""

Commands/stream.py

@@ -0,0 +1,24 @@
+def handle(args, agent):
+    """Toggle streaming mode on/off mid-conversation.
+
+    Usage: /streaming on  or  /streaming off
+    """
+    from Agent.config import save_roles
+
+    arg = args.strip().lower()
+
+    if arg in ("on", "true", "yes"):
+        agent.streaming = True
+        agent.roles[agent.agent_role]["stream"] = True
+        save_roles(agent.roles)
+        print("Streaming: on (saved)")
+    elif arg in ("off", "false", "no"):
+        agent.streaming = False
+        agent.roles[agent.agent_role]["stream"] = False
+        save_roles(agent.roles)
+        print("Streaming: off (saved)")
+    else:
+        state = "on" if agent.streaming else "off"
+        print(f"Streaming: {state}  (usage: /stream on|off)")
+
+    return ""

Commands/undo.py

@@ -0,0 +1,13 @@
+def handle(args, agent):
+    previous_commit = agent.git_manager.undo_last_commit()
+
+    BLUE = "\033[34m"
+    RESET = "\033[0m"
+
+    if previous_commit:
+        print(f"Undid to commit: {previous_commit}\n")
+        print(f"{BLUE}type /redo to redo the last code changes{RESET}")
+
+    else:
+        print("No previous commit to undo")
+    return ""

Commands/unlimited_effort.py

@@ -0,0 +1,8 @@
+def handle(args, agent):
+    """Secret command to set truly unlimited effort depth."""
+    from Agent.effort_levels import UNLIMITED_EFFORT
+    from Agent.chat_history_db import set_session_effort
+
+    set_session_effort(agent.session_id, UNLIMITED_EFFORT)
+    print("Effort: Unlimited")
+    return ""

Commands/window_size.py

@@ -0,0 +1,29 @@
+def handle(args, agent):
+    """Set the context window size mid-conversation.
+
+    Usage: /WindowSize 202752
+    """
+    from Agent.config import save_roles
+
+    arg = args.strip()
+
+    if not arg:
+        current = agent.roles[agent.agent_role].get("context_window", "?")
+        print(f"Context window: {current}  (usage: /WindowSize <number>)")
+        return ""
+
+    try:
+        value = int(arg)
+    except ValueError:
+        print(f"Invalid value '{arg}'. Must be a number.")
+        return ""
+
+    if value <= 0:
+        print("Context window must be positive.")
+        return ""
+
+    agent.roles[agent.agent_role]["context_window"] = value
+    save_roles(agent.roles)
+    print(f"Context window: {value} (saved)")
+
+    return ""

RAG/document.py

@@ -0,0 +1,119 @@
+from pathlib import Path
+
+from indexing.code_index_sdk import CodeIndexSDK
+
+
+def get_symbol_description(symbol_name: str, symbol_type: str = "function", file_path: str = None) -> str:
+    """Get the description of a symbol from the code index database.
+    
+    Args:
+        symbol_name: Name of the symbol to query
+        symbol_type: Type of symbol ("function", "method", "class", or "variable")
+        file_path: Optional file path to disambiguate same-name symbols
+    
+    Returns:
+        Description string or error message
+    """
+    db_path = Path.cwd() / ".raggie" / ".code_index.raggie"
+    
+    if not db_path.exists():
+        return f"Error: Code index database not found at {db_path}"
+
+    with CodeIndexSDK(str(db_path)) as sdk:
+        description = sdk.get_symbol_description_by_name(symbol_type, symbol_name, file_path)
+        
+        if description is None:
+            return f"No description found for {symbol_type} '{symbol_name}'" + (f" in '{file_path}'" if file_path else "")
+        
+        return description
+
+
+def update_symbol_description(symbol_name: str, description: str, symbol_type: str = "function", file_path: str = None) -> str:
+    """Update the description of a symbol in the code index database.
+    
+    Args:
+        symbol_name: Name of the symbol to update
+        description: The description to set
+        symbol_type: Type of symbol ("function", "method", "class", or "variable")
+        file_path: Optional file path to disambiguate same-name symbols
+    
+    Returns:
+        Success message or error message
+    """
+    db_path = Path.cwd() / ".raggie" / ".code_index.raggie"
+    
+    if not db_path.exists():
+        return f"Error: Code index database not found at {db_path}"
+
+    with CodeIndexSDK(str(db_path)) as sdk:
+        if symbol_type in ("function", "method"):
+            matches = sdk.get_function_by_name(symbol_name)
+            if not matches:
+                return f"Error: {symbol_type.capitalize()} '{symbol_name}' not found in code index."
+            
+            # Filter by type if method
+            if symbol_type == "method":
+                matches = [f for f in matches if f.type == "method"]
+                if not matches:
+                    return f"Error: Method '{symbol_name}' not found in code index."
+            
+            # If file_path provided, filter by file
+            if file_path:
+                matches = [f for f in matches if f.file_path == file_path]
+                if not matches:
+                    return f"Error: {symbol_type.capitalize()} '{symbol_name}' not found in file '{file_path}'."
+            
+            func = matches[0]
+            cursor = sdk.conn.cursor()
+            cursor.execute(
+                "UPDATE functions SET description = ? WHERE id = ?",
+                (description, func.id)
+            )
+            sdk.conn.commit()
+            
+            return f"Successfully updated description for {symbol_type} '{symbol_name}' in '{func.file_path}'"
+        
+        elif symbol_type == "class":
+            matches = sdk.get_class_by_name(symbol_name)
+            if not matches:
+                return f"Error: Class '{symbol_name}' not found in code index."
+            
+            # If file_path provided, filter by file
+            if file_path:
+                matches = [c for c in matches if c.file_path == file_path]
+                if not matches:
+                    return f"Error: Class '{symbol_name}' not found in file '{file_path}'."
+            
+            cls = matches[0]
+            cursor = sdk.conn.cursor()
+            cursor.execute(
+                "UPDATE classes SET description = ? WHERE id = ?",
+                (description, cls.id)
+            )
+            sdk.conn.commit()
+            
+            return f"Successfully updated description for class '{symbol_name}' in '{cls.file_path}'"
+        
+        elif symbol_type == "variable":
+            matches = sdk.get_variable_by_name(symbol_name)
+            if not matches:
+                return f"Error: Variable '{symbol_name}' not found in code index."
+            
+            # If file_path provided, filter by file
+            if file_path:
+                matches = [v for v in matches if v.file_path == file_path]
+                if not matches:
+                    return f"Error: Variable '{symbol_name}' not found in file '{file_path}'."
+            
+            var = matches[0]
+            cursor = sdk.conn.cursor()
+            cursor.execute(
+                "UPDATE variables SET description = ? WHERE id = ?",
+                (description, var.id)
+            )
+            sdk.conn.commit()
+            
+            return f"Successfully updated description for variable '{symbol_name}' in '{var.file_path}'"
+        
+        else:
+            return f"Error: Invalid symbol_type '{symbol_type}'. Must be 'function', 'method', 'class', or 'variable'."