Fix all ruff lint and format errors to unblock CI

- Remove unused variables (final_usage, finish_reason, bash_tool, new_table, collection_name)
- Fix module docstrings placed after `from __future__ import annotations` (E402)
- Add `from e`/`from None` to bare raises in except blocks (B904)
- Fix misleading .rstrip("```") → .removesuffix("```") (B005)
- Sort imports in grok_client.py and multi_agent.py (I001)
- Remove quoted return type annotation in GrokClient.__aenter__ (UP037)
- Split semicolon-separated statements in repl.py logo builder (E702)
- Prefix unused loop variable url → _url (B007)
- Fix MCP dispatcher closure to properly bind loop variable (B023)
- Apply ruff format to all 21 affected files

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: loghmanzadeh

grokcode/agent/agent.py

@@ -114,8 +114,6 @@ async def run(
             # Accumulate the full response from streaming
             accumulated_content = ""
             accumulated_tool_calls = []
-            final_usage: TokenUsage | None = None
-            finish_reason: str | None = None
 
             try:
                 async for chunk in self.client.chat(messages, tools=tools, stream=stream):
@@ -124,15 +122,11 @@ async def run(
                         yield ThinkingEvent(text=chunk.content)
                     if chunk.tool_calls:
                         accumulated_tool_calls = chunk.tool_calls
-                        finish_reason = chunk.finish_reason
                     if chunk.usage:
-                        final_usage = chunk.usage
                         total_usage = TokenUsage(
                             input_tokens=total_usage.input_tokens + chunk.usage.input_tokens,
                             output_tokens=total_usage.output_tokens + chunk.usage.output_tokens,
                         )
-                    if chunk.finish_reason:
-                        finish_reason = chunk.finish_reason
 
             except Exception as exc:
                 yield ErrorEvent(message=f"API error: {exc}")
@@ -192,7 +186,9 @@ async def run(
 
         # Exhausted max iterations
         self.message_history = [Message(**m) for m in messages[1:]]
-        yield ErrorEvent(message=f"Max iterations ({MAX_ITERATIONS}) reached without completing task.")
+        yield ErrorEvent(
+            message=f"Max iterations ({MAX_ITERATIONS}) reached without completing task."
+        )
 
 
 async def _get_git_branch() -> str | None:

grokcode/agent/grok_client.py

@@ -8,7 +8,7 @@
 
 import httpx
 
-from grokcode.agent.types import GrokResponse, RawToolCall, ToolCall, TokenUsage
+from grokcode.agent.types import GrokResponse, RawToolCall, TokenUsage, ToolCall
 
 logger = logging.getLogger(__name__)
 
@@ -37,7 +37,7 @@ def __init__(self, api_key: str, model: str = "grok-3-mini", max_tokens: int = 8
     async def close(self) -> None:
         await self._client.aclose()
 
-    async def __aenter__(self) -> "GrokClient":
+    async def __aenter__(self) -> GrokClient:
         return self
 
     async def __aexit__(self, *_: Any) -> None:

grokcode/agent/multi_agent.py

@@ -45,10 +45,20 @@ async def run_multi_agent(
     from grokcode.agent.grok_client import GrokClient
     from grokcode.agent.tool_registry import ToolRegistry
     from grokcode.tools.bash import BashTool
-    from grokcode.tools.fs import FS_TOOL_SCHEMAS, edit_file, glob_files, grep_files, read_directory, read_file, write_file
+    from grokcode.tools.fs import (
+        FS_TOOL_SCHEMAS,
+        edit_file,
+        glob_files,
+        grep_files,
+        read_directory,
+        read_file,
+        write_file,
+    )
     from grokcode.utils.ui import console
 
-    async with GrokClient(api_key=api_key, model=config.model, max_tokens=config.max_tokens) as client:
+    async with GrokClient(
+        api_key=api_key, model=config.model, max_tokens=config.max_tokens
+    ) as client:
         # Step 1: Orchestrator decomposes the task
         console.print("  [cyan]●[/cyan] Orchestrator: decomposing task...")
         subtasks = await _decompose_task(task, config, client)
@@ -84,17 +94,42 @@ async def locked_write_file(path: str, content: str) -> str:
 
         async def run_subtask(subtask: SubtaskPlan) -> list[str]:
             async with semaphore:
-                console.print(f"  [yellow]→[/yellow] Starting sub-agent: {subtask.description[:60]}")
-                bash_tool = BashTool(auto_confirm=auto_confirm)
+                console.print(
+                    f"  [yellow]→[/yellow] Starting sub-agent: {subtask.description[:60]}"
+                )
                 registry = ToolRegistry()
                 registry.register("read_file", lambda path: read_file(path), FS_TOOL_SCHEMAS[0])
-                registry.register("read_directory", lambda path, recursive=False: read_directory(path, recursive), FS_TOOL_SCHEMAS[1])
-                registry.register("write_file", lambda path, content: locked_write_file(path, content), FS_TOOL_SCHEMAS[2])
-                registry.register("edit_file", lambda path, old_str, new_str: locked_edit_file(path, old_str, new_str), FS_TOOL_SCHEMAS[3])
-                registry.register("glob_files", lambda pattern, directory=".": glob_files(pattern, directory), FS_TOOL_SCHEMAS[5])
-                registry.register("grep_files", lambda pattern, directory=".", file_glob="**/*": grep_files(pattern, directory, file_glob), FS_TOOL_SCHEMAS[6])
-
-                async with GrokClient(api_key=api_key, model=config.model, max_tokens=config.max_tokens) as sub_client:
+                registry.register(
+                    "read_directory",
+                    lambda path, recursive=False: read_directory(path, recursive),
+                    FS_TOOL_SCHEMAS[1],
+                )
+                registry.register(
+                    "write_file",
+                    lambda path, content: locked_write_file(path, content),
+                    FS_TOOL_SCHEMAS[2],
+                )
+                registry.register(
+                    "edit_file",
+                    lambda path, old_str, new_str: locked_edit_file(path, old_str, new_str),
+                    FS_TOOL_SCHEMAS[3],
+                )
+                registry.register(
+                    "glob_files",
+                    lambda pattern, directory=".": glob_files(pattern, directory),
+                    FS_TOOL_SCHEMAS[5],
+                )
+                registry.register(
+                    "grep_files",
+                    lambda pattern, directory=".", file_glob="**/*": grep_files(
+                        pattern, directory, file_glob
+                    ),
+                    FS_TOOL_SCHEMAS[6],
+                )
+
+                async with GrokClient(
+                    api_key=api_key, model=config.model, max_tokens=config.max_tokens
+                ) as sub_client:
                     agent = Agent(config=config, tool_registry=registry, grok_client=sub_client)
                     files: list[str] = []
                     async for event in agent.run(
@@ -105,7 +140,9 @@ async def run_subtask(subtask: SubtaskPlan) -> list[str]:
                         if hasattr(event, "files_touched"):
                             files.extend(event.files_touched)  # type: ignore[attr-defined]
                         if isinstance(event, DoneEvent):
-                            console.print(f"  [green]✓[/green] Sub-agent done: {subtask.description[:50]}")
+                            console.print(
+                                f"  [green]✓[/green] Sub-agent done: {subtask.description[:50]}"
+                            )
                         elif isinstance(event, ErrorEvent):
                             console.print(f"  [red]✗[/red] Sub-agent error: {event.message[:80]}")
                     return files
@@ -165,7 +202,7 @@ async def _decompose_task(
             full_response += chunk.content
 
     # Strip markdown fences
-    cleaned = re.sub(r"```(?:json)?\s*", "", full_response).strip().rstrip("```").strip()
+    cleaned = re.sub(r"```(?:json)?\s*", "", full_response).strip().removesuffix("```").strip()
 
     try:
         data = json.loads(cleaned)

grokcode/cli/config_cmd.py

@@ -38,10 +38,10 @@ def config_set(
     if key == "xai_api_key":
         try:
             set_api_key(value)
-            print_success(f"API key stored securely in system keychain.")
+            print_success("API key stored securely in system keychain.")
         except RuntimeError as e:
             print_error(str(e))
-            raise typer.Exit(1)
+            raise typer.Exit(1) from e
         # Also persist masked reference so config show works
         user_config.xai_api_key = value[:8] + "..." if len(value) > 8 else value
         save_user_config(user_config)
@@ -63,7 +63,7 @@ def config_set(
             coerced = value
     except ValueError:
         print_error(f"Invalid value {value!r} for key {key!r}")
-        raise typer.Exit(1)
+        raise typer.Exit(1) from None
 
     setattr(user_config, key, coerced)
     save_user_config(user_config)
@@ -94,12 +94,15 @@ def config_show() -> None:
         ws = config.workspace_config
         table.add_row("workspace", ws.workspace, "grokcode.workspace.json")
         table.add_row("team_id", ws.team_id, "grokcode.workspace.json")
-        table.add_row("collection_id", ws.collection_id or "[dim]not set[/dim]", "grokcode.workspace.json")
+        table.add_row(
+            "collection_id", ws.collection_id or "[dim]not set[/dim]", "grokcode.workspace.json"
+        )
         table.add_row("rules count", str(len(ws.rules)), "grokcode.workspace.json")
         table.add_row("mcp_servers", str(len(ws.mcp_servers)), "grokcode.workspace.json")
 
     console.print(table)
 
     from grokcode.config.config import USER_CONFIG_DIR
+
     console.print(f"\n  [dim]Config dir:[/dim]  {USER_CONFIG_DIR}")
     console.print(f"  [dim]Audit log:[/dim]   {USER_CONFIG_DIR / 'audit.log'}")