refactor(extensions): extract ExtensionResolver from PresetResolver

Move extension template resolution and discovery into a dedicated
ExtensionResolver class in extensions.py. PresetResolver now delegates
its tier-3 (extension) lookups to ExtensionResolver instead of walking
extension directories directly.

This gives extensions their own resolution/discovery API without
coupling them to the preset system. PresetResolver remains the unified
resolver across all 4 tiers but no longer owns extension-specific logic.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: iamaeroplane

src/specify_cli/extensions.py

@@ -847,6 +847,178 @@ def get_extension(self, extension_id: str) -> Optional[ExtensionManifest]:
             return None
 
 
+class ExtensionResolver:
+    """Resolves and discovers templates provided by installed extensions.
+
+    Handles priority-based ordering of extensions, template resolution,
+    and source attribution for extension-provided templates.
+
+    This class owns the extension tier of the template resolution stack.
+    PresetResolver delegates to it for extension lookups rather than
+    walking extension directories directly.
+    """
+
+    def __init__(self, project_root: Path):
+        self.project_root = project_root
+        self.extensions_dir = project_root / ".specify" / "extensions"
+
+    def get_all_by_priority(self) -> List[tuple]:
+        """Build unified list of registered and unregistered extensions sorted by priority.
+
+        Registered extensions use their stored priority; unregistered directories
+        get implicit priority=10. Results are sorted by (priority, ext_id) for
+        deterministic ordering.
+
+        Returns:
+            List of (priority, ext_id, metadata_or_none) tuples sorted by priority.
+        """
+        if not self.extensions_dir.exists():
+            return []
+
+        registry = ExtensionRegistry(self.extensions_dir)
+        registered_extension_ids = registry.keys()
+        all_registered = registry.list_by_priority(include_disabled=True)
+
+        all_extensions: list[tuple[int, str, dict | None]] = []
+
+        for ext_id, metadata in all_registered:
+            if not metadata.get("enabled", True):
+                continue
+            priority = normalize_priority(metadata.get("priority") if metadata else None)
+            all_extensions.append((priority, ext_id, metadata))
+
+        for ext_dir in self.extensions_dir.iterdir():
+            if not ext_dir.is_dir() or ext_dir.name.startswith("."):
+                continue
+            if ext_dir.name not in registered_extension_ids:
+                all_extensions.append((10, ext_dir.name, None))
+
+        all_extensions.sort(key=lambda x: (x[0], x[1]))
+        return all_extensions
+
+    def resolve(
+        self,
+        template_name: str,
+        template_type: str = "template",
+    ) -> Optional[Path]:
+        """Resolve a template name to its file path within extensions.
+
+        Args:
+            template_name: Template name (e.g., "spec-template")
+            template_type: Template type ("template", "command", or "script")
+
+        Returns:
+            Path to the resolved template file, or None if not found
+        """
+        subdirs, ext = self._type_config(template_type)
+
+        for _priority, ext_id, _metadata in self.get_all_by_priority():
+            ext_dir = self.extensions_dir / ext_id
+            if not ext_dir.is_dir():
+                continue
+            for subdir in subdirs:
+                if subdir:
+                    candidate = ext_dir / subdir / f"{template_name}{ext}"
+                else:
+                    candidate = ext_dir / f"{template_name}{ext}"
+                if candidate.exists():
+                    return candidate
+
+        return None
+
+    def resolve_with_source(
+        self,
+        template_name: str,
+        template_type: str = "template",
+    ) -> Optional[Dict[str, str]]:
+        """Resolve a template name and return source attribution.
+
+        Args:
+            template_name: Template name (e.g., "spec-template")
+            template_type: Template type ("template", "command", or "script")
+
+        Returns:
+            Dictionary with 'path' and 'source' keys, or None if not found
+        """
+        subdirs, ext = self._type_config(template_type)
+
+        for _priority, ext_id, ext_meta in self.get_all_by_priority():
+            ext_dir = self.extensions_dir / ext_id
+            if not ext_dir.is_dir():
+                continue
+            for subdir in subdirs:
+                if subdir:
+                    candidate = ext_dir / subdir / f"{template_name}{ext}"
+                else:
+                    candidate = ext_dir / f"{template_name}{ext}"
+                if candidate.exists():
+                    if ext_meta:
+                        version = ext_meta.get("version", "?")
+                        source = f"extension:{ext_id} v{version}"
+                    else:
+                        source = f"extension:{ext_id} (unregistered)"
+                    return {"path": str(candidate), "source": source}
+
+        return None
+
+    def list_templates(
+        self,
+        template_type: str = "template",
+    ) -> List[Dict[str, str]]:
+        """List all templates of a given type provided by extensions.
+
+        Returns templates sorted by extension priority, then alphabetically.
+
+        Args:
+            template_type: Template type ("template", "command", or "script")
+
+        Returns:
+            List of dicts with 'name', 'path', and 'source' keys.
+        """
+        subdirs, ext = self._type_config(template_type)
+        results: List[Dict[str, str]] = []
+        seen: set[str] = set()
+
+        for _priority, ext_id, ext_meta in self.get_all_by_priority():
+            ext_dir = self.extensions_dir / ext_id
+            if not ext_dir.is_dir():
+                continue
+
+            if ext_meta:
+                version = ext_meta.get("version", "?")
+                source_label = f"extension:{ext_id} v{version}"
+            else:
+                source_label = f"extension:{ext_id} (unregistered)"
+
+            for subdir in subdirs:
+                scan_dir = ext_dir / subdir if subdir else ext_dir
+                if not scan_dir.is_dir():
+                    continue
+                for f in sorted(scan_dir.iterdir()):
+                    if f.is_file() and f.suffix == ext:
+                        name = f.stem
+                        if name not in seen:
+                            seen.add(name)
+                            results.append({
+                                "name": name,
+                                "path": str(f),
+                                "source": source_label,
+                            })
+
+        return results
+
+    @staticmethod
+    def _type_config(template_type: str) -> tuple:
+        """Return (subdirs, file_extension) for a template type."""
+        if template_type == "template":
+            return ["templates", ""], ".md"
+        elif template_type == "command":
+            return ["commands"], ".md"
+        elif template_type == "script":
+            return ["scripts"], ".sh"
+        return [""], ".md"
+
+
 def version_satisfies(current: str, required: str) -> bool:
     """Check if current version satisfies required version specifier.
 

src/specify_cli/presets.py

@@ -24,7 +24,7 @@
 from packaging import version as pkg_version
 from packaging.specifiers import SpecifierSet, InvalidSpecifier
 
-from .extensions import ExtensionRegistry, normalize_priority
+from .extensions import ExtensionRegistry, ExtensionResolver, normalize_priority
 
 
 @dataclass
@@ -1529,48 +1529,7 @@ def __init__(self, project_root: Path):
         self.presets_dir = project_root / ".specify" / "presets"
         self.overrides_dir = self.templates_dir / "overrides"
         self.extensions_dir = project_root / ".specify" / "extensions"
-
-    def _get_all_extensions_by_priority(self) -> list[tuple[int, str, dict | None]]:
-        """Build unified list of registered and unregistered extensions sorted by priority.
-
-        Registered extensions use their stored priority; unregistered directories
-        get implicit priority=10. Results are sorted by (priority, ext_id) for
-        deterministic ordering.
-
-        Returns:
-            List of (priority, ext_id, metadata_or_none) tuples sorted by priority.
-        """
-        if not self.extensions_dir.exists():
-            return []
-
-        registry = ExtensionRegistry(self.extensions_dir)
-        # Use keys() to track ALL extensions (including corrupted entries) without deep copy
-        # This prevents corrupted entries from being picked up as "unregistered" dirs
-        registered_extension_ids = registry.keys()
-
-        # Get all registered extensions including disabled; we filter disabled manually below
-        all_registered = registry.list_by_priority(include_disabled=True)
-
-        all_extensions: list[tuple[int, str, dict | None]] = []
-
-        # Only include enabled extensions in the result
-        for ext_id, metadata in all_registered:
-            # Skip disabled extensions
-            if not metadata.get("enabled", True):
-                continue
-            priority = normalize_priority(metadata.get("priority") if metadata else None)
-            all_extensions.append((priority, ext_id, metadata))
-
-        # Add unregistered directories with implicit priority=10
-        for ext_dir in self.extensions_dir.iterdir():
-            if not ext_dir.is_dir() or ext_dir.name.startswith("."):
-                continue
-            if ext_dir.name not in registered_extension_ids:
-                all_extensions.append((10, ext_dir.name, None))
-
-        # Sort by (priority, ext_id) for deterministic ordering
-        all_extensions.sort(key=lambda x: (x[0], x[1]))
-        return all_extensions
+        self._ext_resolver = ExtensionResolver(project_root)
 
     def resolve(
         self,
@@ -1624,18 +1583,10 @@ def resolve(
                     if candidate.exists():
                         return candidate
 
-        # Priority 3: Extension-provided templates (sorted by priority — lower number wins)
-        for _priority, ext_id, _metadata in self._get_all_extensions_by_priority():
-            ext_dir = self.extensions_dir / ext_id
-            if not ext_dir.is_dir():
-                continue
-            for subdir in subdirs:
-                if subdir:
-                    candidate = ext_dir / subdir / f"{template_name}{ext}"
-                else:
-                    candidate = ext_dir / f"{template_name}{ext}"
-                if candidate.exists():
-                    return candidate
+        # Priority 3: Extension-provided templates (delegated to ExtensionResolver)
+        ext_result = self._ext_resolver.resolve(template_name, template_type)
+        if ext_result is not None:
+            return ext_result
 
         # Priority 4: Core templates
         if template_type == "template":
@@ -1693,7 +1644,7 @@ def resolve_with_source(
                 except ValueError:
                     continue
 
-        for _priority, ext_id, ext_meta in self._get_all_extensions_by_priority():
+        for _priority, ext_id, ext_meta in self._ext_resolver.get_all_by_priority():
             ext_dir = self.extensions_dir / ext_id
             if not ext_dir.is_dir():
                 continue
@@ -1779,21 +1730,11 @@ def _collect(directory: Path, source: str):
                     else:
                         _collect(pack_dir, source_label)
 
-        # Priority 3: Extension-provided templates (sorted by priority)
-        for _priority, ext_id, ext_meta in self._get_all_extensions_by_priority():
-            ext_dir = self.extensions_dir / ext_id
-            if not ext_dir.is_dir():
-                continue
-            if ext_meta:
-                version = ext_meta.get("version", "?")
-                source_label = f"extension:{ext_id} v{version}"
-            else:
-                source_label = f"extension:{ext_id} (unregistered)"
-            for subdir in subdirs:
-                if subdir:
-                    _collect(ext_dir / subdir, source_label)
-                else:
-                    _collect(ext_dir, source_label)
+        # Priority 3: Extension-provided templates (delegated to ExtensionResolver)
+        for entry in self._ext_resolver.list_templates(template_type):
+            if entry["name"] not in seen:
+                seen.add(entry["name"])
+                results.append(entry)
 
         # Priority 4: Core templates
         if template_type == "template":