chore: apply pre-commit formatting fixes

Normalize formatting after running the project pre-commit hooks and fix the remaining ruff warnings.

Made-with: Cursor

Author: Zongwei9888

cli/cli_app.py

@@ -406,9 +406,7 @@ async def _handle_at_shortcut(self, target: str) -> str:
         case the user already saw an error toast).
         """
         if not target:
-            self.cli.print_status(
-                "Usage: @<file-path>   or   @<url>", "warning"
-            )
+            self.cli.print_status("Usage: @<file-path>   or   @<url>", "warning")
             return ""
 
         # Strip optional surrounding quotes (clipboard pastes often
@@ -422,24 +420,18 @@ async def _handle_at_shortcut(self, target: str) -> str:
 
         # URL branch — anything starting with http(s)://
         if lowered.startswith(("http://", "https://")):
-            self.cli.print_status(
-                f"@-shortcut → URL: {target}", "info"
-            )
+            self.cli.print_status(f"@-shortcut → URL: {target}", "info")
             await self.process_input(target, "url")
             return "u"
 
         # File branch — accept ``file://`` prefix and existence check.
-        raw_path = target[len("file://"):] if lowered.startswith("file://") else target
+        raw_path = target[len("file://") :] if lowered.startswith("file://") else target
         if not os.path.exists(raw_path):
-            self.cli.print_status(
-                f"Path not found: {raw_path}", "error"
-            )
+            self.cli.print_status(f"Path not found: {raw_path}", "error")
             return ""
 
         abspath = os.path.abspath(raw_path)
-        self.cli.print_status(
-            f"@-shortcut → File: {abspath}", "info"
-        )
+        self.cli.print_status(f"@-shortcut → File: {abspath}", "info")
         await self.process_input(f"file://{abspath}", "file")
         return "f"
 
@@ -465,9 +457,7 @@ def _handle_slash_command(self, raw: str) -> None:
             from core.observability import current_session_id, set_session
             from core.sessions import get_default_store
         except Exception as exc:
-            self.cli.print_status(
-                f"Session subsystem unavailable: {exc}", "error"
-            )
+            self.cli.print_status(f"Session subsystem unavailable: {exc}", "error")
             return
 
         parts = raw.strip().split(maxsplit=1)
@@ -483,9 +473,7 @@ def _handle_slash_command(self, raw: str) -> None:
         if cmd in ("/session", "/whoami"):
             sid = current_session_id()
             session = store.get_session(sid) if sid else None
-            self.cli.print_active_session(
-                sid, session.title if session else None
-            )
+            self.cli.print_active_session(sid, session.title if session else None)
             return
 
         if cmd in ("/resume", "/sessions", "/load"):
@@ -497,9 +485,7 @@ def _handle_slash_command(self, raw: str) -> None:
             if session is None:
                 # Treat input as a prefix — try to disambiguate against
                 # the listed summaries before giving up.
-                candidates = [
-                    s for s in summaries if s.session_id.startswith(picked)
-                ]
+                candidates = [s for s in summaries if s.session_id.startswith(picked)]
                 if len(candidates) == 1:
                     session = store.get_session(candidates[0].session_id)
                 elif len(candidates) > 1:
@@ -510,9 +496,7 @@ def _handle_slash_command(self, raw: str) -> None:
                     )
                     return
             if session is None:
-                self.cli.print_status(
-                    f"Session '{picked}' not found.", "error"
-                )
+                self.cli.print_status(f"Session '{picked}' not found.", "error")
                 return
             set_session(session.session_id)
             self.cli.print_status(
@@ -578,9 +562,7 @@ async def run_interactive_session(self):
                 # ask_continue check below behaves the same as if the
                 # user had picked [F] / [U] from the menu.
                 if choice_raw.startswith("@"):
-                    effective = await self._handle_at_shortcut(
-                        choice_raw[1:].strip()
-                    )
+                    effective = await self._handle_at_shortcut(choice_raw[1:].strip())
                     if effective in ("f", "u"):
                         choice = effective
                     else:

cli/cli_interface.py

@@ -301,8 +301,7 @@ def pick_session_interactive(self, summaries) -> Optional[str]:
             f"({len(summaries)} total){Colors.ENDC}"
         )
         header = (
-            f"  {'#':<3} {'ID':<10} {'Updated':<26} "
-            f"{'Tasks':<6} {'Msgs':<6} Title"
+            f"  {'#':<3} {'ID':<10} {'Updated':<26} " f"{'Tasks':<6} {'Msgs':<6} Title"
         )
         print(f"{Colors.BOLD}{header}{Colors.ENDC}")
         print("  " + "-" * (len(header) - 2))

cli/main_cli.py

@@ -303,7 +303,9 @@ def handle_session_command(args):
     if sub == "show":
         target = args.session_arg or args.session
         if not target:
-            print(f"{Colors.FAIL}Usage: deepcode session show <session_id>{Colors.ENDC}")
+            print(
+                f"{Colors.FAIL}Usage: deepcode session show <session_id>{Colors.ENDC}"
+            )
             return 1
         session = store.get_session(target)
         if session is None:
@@ -315,7 +317,9 @@ def handle_session_command(args):
     if sub == "resume":
         target = args.session_arg or args.session
         if not target:
-            print(f"{Colors.FAIL}Usage: deepcode session resume <session_id>{Colors.ENDC}")
+            print(
+                f"{Colors.FAIL}Usage: deepcode session resume <session_id>{Colors.ENDC}"
+            )
             return 1
         session = store.get_session(target)
         if session is None:
@@ -338,7 +342,9 @@ def handle_session_command(args):
     if sub == "delete":
         target = args.session_arg
         if not target:
-            print(f"{Colors.FAIL}Usage: deepcode session delete <session_id>{Colors.ENDC}")
+            print(
+                f"{Colors.FAIL}Usage: deepcode session delete <session_id>{Colors.ENDC}"
+            )
             return 1
         if store.delete_session(target):
             print(f"{Colors.OKGREEN}Deleted session {target}{Colors.ENDC}")

core/agent_runtime/helpers.py

@@ -121,7 +121,9 @@ def _bucket_mtime(path: Path) -> float:
 
 
 def _cleanup_tool_result_buckets(root: Path, current_bucket: Path) -> None:
-    siblings = [path for path in root.iterdir() if path.is_dir() and path != current_bucket]
+    siblings = [
+        path for path in root.iterdir() if path.is_dir() and path != current_bucket
+    ]
     cutoff = time.time() - _TOOL_RESULT_RETENTION_SECS
     for path in siblings:
         if _bucket_mtime(path) < cutoff:
@@ -205,7 +207,9 @@ def build_assistant_message(
     if tool_calls:
         msg["tool_calls"] = tool_calls
     if reasoning_content is not None or thinking_blocks:
-        msg["reasoning_content"] = reasoning_content if reasoning_content is not None else ""
+        msg["reasoning_content"] = (
+            reasoning_content if reasoning_content is not None else ""
+        )
     if thinking_blocks:
         msg["thinking_blocks"] = thinking_blocks
     return msg

core/agent_runtime/hook.py

@@ -50,7 +50,9 @@ async def before_execute_tools(self, context: AgentHookContext) -> None:
     async def after_iteration(self, context: AgentHookContext) -> None:
         pass
 
-    def finalize_content(self, context: AgentHookContext, content: str | None) -> str | None:
+    def finalize_content(
+        self, context: AgentHookContext, content: str | None
+    ) -> str | None:
         return content
 
 
@@ -66,7 +68,9 @@ def __init__(self, hooks: list[AgentHook]) -> None:
     def wants_streaming(self) -> bool:
         return any(h.wants_streaming() for h in self._hooks)
 
-    async def _for_each_hook_safe(self, method_name: str, *args: Any, **kwargs: Any) -> None:
+    async def _for_each_hook_safe(
+        self, method_name: str, *args: Any, **kwargs: Any
+    ) -> None:
         for h in self._hooks:
             if getattr(h, "_reraise", False):
                 await getattr(h, method_name)(*args, **kwargs)
@@ -75,7 +79,9 @@ async def _for_each_hook_safe(self, method_name: str, *args: Any, **kwargs: Any)
             try:
                 await getattr(h, method_name)(*args, **kwargs)
             except Exception:
-                logger.exception("AgentHook.{} error in {}", method_name, type(h).__name__)
+                logger.exception(
+                    "AgentHook.{} error in {}", method_name, type(h).__name__
+                )
 
     async def before_iteration(self, context: AgentHookContext) -> None:
         await self._for_each_hook_safe("before_iteration", context)
@@ -92,7 +98,9 @@ async def before_execute_tools(self, context: AgentHookContext) -> None:
     async def after_iteration(self, context: AgentHookContext) -> None:
         await self._for_each_hook_safe("after_iteration", context)
 
-    def finalize_content(self, context: AgentHookContext, content: str | None) -> str | None:
+    def finalize_content(
+        self, context: AgentHookContext, content: str | None
+    ) -> str | None:
         for h in self._hooks:
             content = h.finalize_content(context, content)
         return content

core/agent_runtime/runner.py

@@ -123,7 +123,9 @@ def _merge_message_content(left: Any, right: Any) -> str | list[dict[str, Any]]:
         def _to_blocks(value: Any) -> list[dict[str, Any]]:
             if isinstance(value, list):
                 return [
-                    item if isinstance(item, dict) else {"type": "text", "text": str(item)}
+                    item
+                    if isinstance(item, dict)
+                    else {"type": "text", "text": str(item)}
                     for item in value
                 ]
             if value is None:
@@ -213,7 +215,11 @@ async def _drain_injections(self, spec: AgentRunSpec) -> list[dict[str, Any]]:
             return []
         injected_messages: list[dict[str, Any]] = []
         for item in items:
-            if isinstance(item, dict) and item.get("role") == "user" and "content" in item:
+            if (
+                isinstance(item, dict)
+                and item.get("role") == "user"
+                and "content" in item
+            ):
                 injected_messages.append(item)
                 continue
             text = getattr(item, "content", str(item))
@@ -248,12 +254,18 @@ async def run(self, spec: AgentRunSpec) -> AgentRunResult:
         for iteration in range(spec.max_iterations):
             try:
                 messages_for_model = self._drop_orphan_tool_results(messages)
-                messages_for_model = self._backfill_missing_tool_results(messages_for_model)
+                messages_for_model = self._backfill_missing_tool_results(
+                    messages_for_model
+                )
                 messages_for_model = self._microcompact(messages_for_model)
-                messages_for_model = self._apply_tool_result_budget(spec, messages_for_model)
+                messages_for_model = self._apply_tool_result_budget(
+                    spec, messages_for_model
+                )
                 messages_for_model = self._snip_history(spec, messages_for_model)
                 messages_for_model = self._drop_orphan_tool_results(messages_for_model)
-                messages_for_model = self._backfill_missing_tool_results(messages_for_model)
+                messages_for_model = self._backfill_missing_tool_results(
+                    messages_for_model
+                )
             except Exception as exc:
                 logger.warning(
                     "Context governance failed on turn {} for {}: {}; applying minimal repair",
@@ -263,12 +275,16 @@ async def run(self, spec: AgentRunSpec) -> AgentRunResult:
                 )
                 try:
                     messages_for_model = self._drop_orphan_tool_results(messages)
-                    messages_for_model = self._backfill_missing_tool_results(messages_for_model)
+                    messages_for_model = self._backfill_missing_tool_results(
+                        messages_for_model
+                    )
                 except Exception:
                     messages_for_model = messages
             context = AgentHookContext(iteration=iteration, messages=messages)
             await hook.before_iteration(context)
-            response = await self._request_model(spec, messages_for_model, hook, context)
+            response = await self._request_model(
+                spec, messages_for_model, hook, context
+            )
             raw_usage = self._usage_dict(response.usage)
             context.response = response
             context.usage = dict(raw_usage)
@@ -335,7 +351,10 @@ async def run(self, spec: AgentRunSpec) -> AgentRunResult:
                     context.error = error
                     context.stop_reason = stop_reason
                     await hook.after_iteration(context)
-                    should_continue, injection_cycles = await self._try_drain_injections(
+                    (
+                        should_continue,
+                        injection_cycles,
+                    ) = await self._try_drain_injections(
                         spec,
                         messages,
                         None,
@@ -401,7 +420,9 @@ async def run(self, spec: AgentRunSpec) -> AgentRunResult:
                 )
                 if hook.wants_streaming():
                     await hook.on_stream_end(context, resuming=False)
-                response = await self._request_finalization_retry(spec, messages_for_model)
+                response = await self._request_finalization_retry(
+                    spec, messages_for_model
+                )
                 retry_usage = self._usage_dict(response.usage)
                 self._accumulate_usage(usage, retry_usage)
                 raw_usage = self._merge_usage(raw_usage, retry_usage)
@@ -529,7 +550,10 @@ async def run(self, spec: AgentRunSpec) -> AgentRunResult:
             template = spec.max_iterations_message or _DEFAULT_MAX_ITERATIONS_MESSAGE
             final_content = template.format(max_iterations=spec.max_iterations)
             self._append_final_message(messages, final_content)
-            drained_after_max_iterations, injection_cycles = await self._try_drain_injections(
+            (
+                drained_after_max_iterations,
+                injection_cycles,
+            ) = await self._try_drain_injections(
                 spec,
                 messages,
                 None,
@@ -775,7 +799,9 @@ async def _emit_checkpoint(
             await callback(payload)
 
     @staticmethod
-    def _append_final_message(messages: list[dict[str, Any]], content: str | None) -> None:
+    def _append_final_message(
+        messages: list[dict[str, Any]], content: str | None
+    ) -> None:
         if not content:
             return
         if (
@@ -873,7 +899,9 @@ def _backfill_missing_tool_results(
                 if tid:
                     fulfilled.add(str(tid))
 
-        missing = [(ai, cid, name) for ai, cid, name in declared if cid not in fulfilled]
+        missing = [
+            (ai, cid, name) for ai, cid, name in declared if cid not in fulfilled
+        ]
         if not missing:
             return messages
 
@@ -905,7 +933,9 @@ def _microcompact(messages: list[dict[str, Any]]) -> list[dict[str, Any]]:
         if len(compactable_indices) <= _MICROCOMPACT_KEEP_RECENT:
             return messages
 
-        stale = compactable_indices[: len(compactable_indices) - _MICROCOMPACT_KEEP_RECENT]
+        stale = compactable_indices[
+            : len(compactable_indices) - _MICROCOMPACT_KEEP_RECENT
+        ]
         updated: list[dict[str, Any]] | None = None
         for idx in stale:
             msg = messages[idx]
@@ -949,7 +979,9 @@ def _snip_history(
         if not messages or not spec.context_window_tokens:
             return messages
 
-        provider_max_tokens = getattr(getattr(self.provider, "generation", None), "max_tokens", 4096)
+        provider_max_tokens = getattr(
+            getattr(self.provider, "generation", None), "max_tokens", 4096
+        )
         max_output = (
             spec.max_tokens
             if isinstance(spec.max_tokens, int)

core/agent_runtime/runtime.py

@@ -61,7 +61,9 @@ def external_lookup_signature(tool_name: str, arguments: dict[str, Any]) -> str
         if url:
             return f"web_fetch:{url.lower()}"
     if tool_name == "web_search":
-        query = str(arguments.get("query") or arguments.get("search_term") or "").strip()
+        query = str(
+            arguments.get("query") or arguments.get("search_term") or ""
+        ).strip()
         if query:
             return f"web_search:{query.lower()}"
     return None