Hi, Jules here! I've gone ahead and improved the code health by deduplicating the snapshot loading logic.

I extracted the duplicate snapshot parsing logic from `src/tools.py` and `src/commands.py` and moved it into a shared `load_porting_modules` utility function within a new `src/snapshot_loader.py` file. This reduces duplicate code and significantly improves maintainability. Going forward, any changes to how snapshots are loaded or how `PortingModule` objects are constructed from them can now be managed in a single place!

Co-authored-by: google-labs-jules[bot] <161369871+google-labs-jules[bot]@users.noreply.github.com>

Author: badMade

src/commands.py

@@ -1,13 +1,13 @@
 from __future__ import annotations
 
-import json
 from collections.abc import Mapping
 from dataclasses import dataclass
 from functools import lru_cache
 from pathlib import Path
 from types import MappingProxyType
 
 from .models import PortingBacklog, PortingModule
+from .snapshot_loader import load_porting_modules
 
 SNAPSHOT_PATH = (
     Path(__file__).resolve().parent / "reference_data" / "commands_snapshot.json"
@@ -25,16 +25,7 @@ class CommandExecution:
 
 @lru_cache(maxsize=1)
 def load_command_snapshot() -> tuple[PortingModule, ...]:
-    raw_entries = json.loads(SNAPSHOT_PATH.read_text())
-    return tuple(
-        PortingModule(
-            name=entry["name"],
-            responsibility=entry["responsibility"],
-            source_hint=entry["source_hint"],
-            status="mirrored",
-        )
-        for entry in raw_entries
-    )
+    return load_porting_modules(SNAPSHOT_PATH)
 
 
 PORTED_COMMANDS = load_command_snapshot()

src/snapshot_loader.py

@@ -0,0 +1,17 @@
+import json
+from pathlib import Path
+
+from .models import PortingModule
+
+
+def load_porting_modules(snapshot_path: Path) -> tuple[PortingModule, ...]:
+    raw_entries = json.loads(snapshot_path.read_text())
+    return tuple(
+        PortingModule(
+            name=entry["name"],
+            responsibility=entry["responsibility"],
+            source_hint=entry["source_hint"],
+            status="mirrored",
+        )
+        for entry in raw_entries
+    )

src/tools.py

@@ -1,14 +1,16 @@
 from __future__ import annotations
 
-import json
 from dataclasses import dataclass
 from functools import lru_cache
 from pathlib import Path
 
 from .models import PortingBacklog, PortingModule
+from .snapshot_loader import load_porting_modules
 from .permissions import ToolPermissionContext
 
-SNAPSHOT_PATH = Path(__file__).resolve().parent / 'reference_data' / 'tools_snapshot.json'
+SNAPSHOT_PATH = (
+    Path(__file__).resolve().parent / "reference_data" / "tools_snapshot.json"
+)
 
 
 @dataclass(frozen=True)
@@ -22,23 +24,14 @@ class ToolExecution:
 
 @lru_cache(maxsize=1)
 def load_tool_snapshot() -> tuple[PortingModule, ...]:
-    raw_entries = json.loads(SNAPSHOT_PATH.read_text())
-    return tuple(
-        PortingModule(
-            name=entry['name'],
-            responsibility=entry['responsibility'],
-            source_hint=entry['source_hint'],
-            status='mirrored',
-        )
-        for entry in raw_entries
-    )
+    return load_porting_modules(SNAPSHOT_PATH)
 
 
 PORTED_TOOLS = load_tool_snapshot()
 
 
 def build_tool_backlog() -> PortingBacklog:
-    return PortingBacklog(title='Tool surface', modules=list(PORTED_TOOLS))
+    return PortingBacklog(title="Tool surface", modules=list(PORTED_TOOLS))
 
 
 def tool_names() -> list[str]:
@@ -53,10 +46,15 @@ def get_tool(name: str) -> PortingModule | None:
     return None
 
 
-def filter_tools_by_permission_context(tools: tuple[PortingModule, ...], permission_context: ToolPermissionContext | None = None) -> tuple[PortingModule, ...]:
+def filter_tools_by_permission_context(
+    tools: tuple[PortingModule, ...],
+    permission_context: ToolPermissionContext | None = None,
+) -> tuple[PortingModule, ...]:
     if permission_context is None:
         return tools
-    return tuple(module for module in tools if not permission_context.blocks(module.name))
+    return tuple(
+        module for module in tools if not permission_context.blocks(module.name)
+    )
 
 
 def get_tools(
@@ -66,31 +64,56 @@ def get_tools(
 ) -> tuple[PortingModule, ...]:
     tools = list(PORTED_TOOLS)
     if simple_mode:
-        tools = [module for module in tools if module.name in {'BashTool', 'FileReadTool', 'FileEditTool'}]
+        tools = [
+            module
+            for module in tools
+            if module.name in {"BashTool", "FileReadTool", "FileEditTool"}
+        ]
     if not include_mcp:
-        tools = [module for module in tools if 'mcp' not in module.name.lower() and 'mcp' not in module.source_hint.lower()]
+        tools = [
+            module
+            for module in tools
+            if "mcp" not in module.name.lower()
+            and "mcp" not in module.source_hint.lower()
+        ]
     return filter_tools_by_permission_context(tuple(tools), permission_context)
 
 
 def find_tools(query: str, limit: int = 20) -> list[PortingModule]:
     needle = query.lower()
-    matches = [module for module in PORTED_TOOLS if needle in module.name.lower() or needle in module.source_hint.lower()]
+    matches = [
+        module
+        for module in PORTED_TOOLS
+        if needle in module.name.lower() or needle in module.source_hint.lower()
+    ]
     return matches[:limit]
 
 
-def execute_tool(name: str, payload: str = '') -> ToolExecution:
+def execute_tool(name: str, payload: str = "") -> ToolExecution:
     module = get_tool(name)
     if module is None:
-        return ToolExecution(name=name, source_hint='', payload=payload, handled=False, message=f'Unknown mirrored tool: {name}')
+        return ToolExecution(
+            name=name,
+            source_hint="",
+            payload=payload,
+            handled=False,
+            message=f"Unknown mirrored tool: {name}",
+        )
     action = f"Mirrored tool '{module.name}' from {module.source_hint} would handle payload {payload!r}."
-    return ToolExecution(name=module.name, source_hint=module.source_hint, payload=payload, handled=True, message=action)
+    return ToolExecution(
+        name=module.name,
+        source_hint=module.source_hint,
+        payload=payload,
+        handled=True,
+        message=action,
+    )
 
 
 def render_tool_index(limit: int = 20, query: str | None = None) -> str:
     modules = find_tools(query, limit) if query else list(PORTED_TOOLS[:limit])
-    lines = [f'Tool entries: {len(PORTED_TOOLS)}', '']
+    lines = [f"Tool entries: {len(PORTED_TOOLS)}", ""]
     if query:
-        lines.append(f'Filtered by: {query}')
-        lines.append('')
-    lines.extend(f'- {module.name} — {module.source_hint}' for module in modules)
-    return '\n'.join(lines)
+        lines.append(f"Filtered by: {query}")
+        lines.append("")
+    lines.extend(f"- {module.name} — {module.source_hint}" for module in modules)
+    return "\n".join(lines)