codd-dev 2.86.0__tar.gz → 2.88.0__tar.gz

{codd_dev-2.86.0 → codd_dev-2.88.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codd-dev
-Version: 2.86.0
+Version: 2.88.0
 Summary: CoDD: Coherence-Driven Development — cross-artifact change impact analysis
 Project-URL: Homepage, https://github.com/yohey-w/codd-dev
 Project-URL: Repository, https://github.com/yohey-w/codd-dev

{codd_dev-2.86.0 → codd_dev-2.88.0}/codd/__init__.py

@@ -1,3 +1,3 @@
 """CoDD — Coherence-Driven Development."""
 
-__version__ = "2.86.0"
+__version__ = "2.88.0"

{codd_dev-2.86.0 → codd_dev-2.88.0}/codd/e2e_harness.py

@@ -40,6 +40,7 @@ from collections.abc import Mapping
 from dataclasses import dataclass
 from typing import Any, Literal
 
+from codd.parsing.regex_strategies import language_extensions
 from codd.project_types import ProjectCapabilities
 
 
@@ -234,7 +235,11 @@ def resolve_e2e_harness(
     """
 
     lang = (project_language or "").strip().lower()
-    is_python = lang == "python"
+    # "host language is Python" is driven from the language's declared source
+    # extensions (registry DATA: ``regex_strategies.language_extensions`` is
+    # canonical-keyed — it does NOT resolve aliases — so this is byte-identical
+    # to the former ``lang == "python"``), not a language-name branch in core.
+    is_python = ".py" in language_extensions(lang)
     modality = capabilities.e2e_modality
 
     if modality == "cli":

{codd_dev-2.86.0 → codd_dev-2.88.0}/codd/extractor.py

@@ -365,13 +365,14 @@ def _detect_test_dirs(project_root: Path) -> list[str]:
 
 
 def _language_extensions(language: str) -> set[str]:
-    return {
-        "python": {".py"},
-        "typescript": {".ts", ".tsx"},
-        "javascript": {".js", ".jsx"},
-        "java": {".java"},
-        "go": {".go"},
-    }.get(language, set())
+    """Source-file extensions for ``language`` (registry-data lookup).
+
+    Contract Kernel Cut Condition A: no language-name keyed dict in core — the
+    extension table lives in the registry-DATA strategy. Byte-identical.
+    """
+    from codd.parsing.regex_strategies import language_extensions
+
+    return language_extensions(language)
 
 
 def _discover_modules(facts: ProjectFacts, project_root: Path, src_dir: Path,
@@ -473,92 +474,36 @@ def _schema_has_data(schema_info: Any) -> bool:
 
 def _file_to_module(rel_path: str, project_root: Path, src_dir: Path,
                     language: str) -> str:
-    """Map a file path to its module name."""
-    rel_to_src = Path(rel_path).relative_to(src_dir.relative_to(project_root))
+    """Map a file path to its module name.
 
-    if language == "python":
-        parts = list(rel_to_src.parts)
-        # Remove .py extension from last part
-        if parts and parts[-1].endswith(".py"):
-            parts[-1] = parts[-1][:-3]
-        # If file is __init__.py, module is the parent directory
-        if parts and parts[-1] == "__init__":
-            parts.pop()
-        # Top-level module name
-        if parts:
-            return parts[0]
-        return rel_to_src.parent.name or "root"
-
-    elif language in ("typescript", "javascript"):
-        parts = list(rel_to_src.parts)
-        if parts:
-            return parts[0]
-        return "root"
-
-    elif language == "java":
-        # Use top-level directory under src
-        parts = list(rel_to_src.parts)
-        # Skip standard layout dirs (main/java, main/kotlin)
-        skip = {"main", "java", "kotlin", "scala"}
-        parts = [p for p in parts if p not in skip]
-        if parts:
-            return parts[0]
-        return "root"
-
-    elif language == "go":
-        parts = list(rel_to_src.parts)
-        if parts:
-            return parts[0]
-        return "root"
+    Contract Kernel Cut Condition A: dispatches through the registry-DATA
+    strategy's ``file_to_module`` rule (no ``if language ==`` branch). The
+    generic strategy reproduces the former trailing ``return parts[0]``
+    default; behaviour is byte-identical.
+    """
+    from codd.parsing.regex_strategies import strategy_for
 
+    rel_to_src = Path(rel_path).relative_to(src_dir.relative_to(project_root))
+    rule = strategy_for(language).file_to_module
+    if rule is not None:
+        result = rule(rel_to_src)
+        if result is not None:
+            return result
     return rel_to_src.parts[0] if rel_to_src.parts else "root"
 
 
 def _extract_symbols(content: str, rel_path: str, language: str) -> list[Symbol]:
-    """Extract classes and functions from source code (regex-based MVP)."""
-    symbols = []
-
-    if language == "python":
-        for i, line in enumerate(content.splitlines(), 1):
-            m = re.match(r'^\s*class\s+(\w+)', line)
-            if m:
-                symbols.append(Symbol(m.group(1), "class", rel_path, i))
-            m = re.match(r'^\s*(?:async\s+)?def\s+(\w+)\s*\(([^)]*)\)', line)
-            if m and not m.group(1).startswith("_"):
-                symbols.append(Symbol(m.group(1), "function", rel_path, i, m.group(2).strip()))
-
-    elif language in ("typescript", "javascript"):
-        for i, line in enumerate(content.splitlines(), 1):
-            m = re.match(r'^(?:export\s+)?class\s+(\w+)', line)
-            if m:
-                symbols.append(Symbol(m.group(1), "class", rel_path, i))
-            m = re.match(r'^(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(([^)]*)\)', line)
-            if m:
-                symbols.append(Symbol(m.group(1), "function", rel_path, i, m.group(2).strip()))
-            # Arrow function exports
-            m = re.match(r'^export\s+const\s+(\w+)\s*=\s*(?:async\s+)?\(', line)
-            if m:
-                symbols.append(Symbol(m.group(1), "function", rel_path, i))
-
-    elif language == "java":
-        for i, line in enumerate(content.splitlines(), 1):
-            m = re.match(r'^\s*(?:public|protected|private)?\s*(?:static\s+)?(?:abstract\s+)?class\s+(\w+)', line)
-            if m:
-                symbols.append(Symbol(m.group(1), "class", rel_path, i))
-            m = re.match(r'^\s*(?:public|protected)\s+(?:static\s+)?[\w<>\[\],\s]+\s+(\w+)\s*\(([^)]*)\)', line)
-            if m and m.group(1)[0].islower():
-                symbols.append(Symbol(m.group(1), "function", rel_path, i, m.group(2).strip()))
-
-    elif language == "go":
-        for i, line in enumerate(content.splitlines(), 1):
-            m = re.match(r'^type\s+(\w+)\s+struct\s*\{', line)
-            if m:
-                symbols.append(Symbol(m.group(1), "class", rel_path, i))
-            m = re.match(r'^func\s+(?:\(\w+\s+\*?\w+\)\s+)?(\w+)\s*\(([^)]*)\)', line)
-            if m and m.group(1)[0].isupper():
-                symbols.append(Symbol(m.group(1), "function", rel_path, i, m.group(2).strip()))
-
-    return symbols
+    """Extract classes and functions from source code (regex-based MVP).
+
+    Contract Kernel Cut Condition A: this core function no longer branches on a
+    language name — it dispatches through the registry-DATA strategy for
+    ``language`` (see :mod:`codd.parsing.regex_strategies`). The per-language
+    regex bodies live in that strategy table (the allowed extractor-impl zone);
+    behaviour is byte-identical to the former inline ladder.
+    """
+    from codd.parsing.regex_strategies import strategy_for
+
+    return strategy_for(language).symbols(content, rel_path)
 
 
 def _extract_imports(content: str, language: str, project_root: Path,
@@ -566,105 +511,26 @@ def _extract_imports(content: str, language: str, project_root: Path,
     """Extract imports, classified as internal or external.
 
     Returns (internal_imports: {module_name: [import_lines]}, external_imports: set)
-    """
-    internal: dict[str, list[str]] = {}
-    external: set[str] = set()
-
-    if language == "python":
-        # Determine package name of the source dir itself
-        src_pkg_name = src_dir.name if (src_dir / "__init__.py").exists() else None
-
-        for line in content.splitlines():
-            m = re.match(r'^(?:from|import)\s+([\w.]+)', line.strip())
-            if not m:
-                continue
-            module = m.group(1)
-            parts = module.split(".")
-            top_level = parts[0]
-
-            # Check if it's an internal module
-            is_internal = False
-            internal_key = top_level
-
-            # Case 1: import references the source package itself (e.g., from codd.graph)
-            if src_pkg_name and top_level == src_pkg_name and len(parts) >= 2:
-                is_internal = True
-                internal_key = parts[1]  # Use sub-module as the key
-            else:
-                # Case 2: import references a sibling directory/file
-                for sd in [src_dir] + [project_root / d for d in ("src", "lib", "app") if (project_root / d).is_dir()]:
-                    if (sd / top_level).is_dir() or (sd / f"{top_level}.py").is_file():
-                        is_internal = True
-                        break
-
-            if is_internal:
-                internal.setdefault(internal_key, []).append(line.strip())
-            else:
-                external.add(top_level)
 
-    elif language in ("typescript", "javascript"):
-        for line in content.splitlines():
-            m = re.search(r'''(?:import|from)\s+['"]([^'"]+)['"]''', line)
-            if not m:
-                continue
-            import_path = m.group(1)
-            if import_path.startswith("."):
-                # Relative import → internal
-                resolved = (file_path.parent / import_path).resolve()
-                try:
-                    rel = resolved.relative_to(src_dir)
-                    top_level = rel.parts[0] if rel.parts else "root"
-                    internal.setdefault(top_level, []).append(line.strip())
-                except ValueError:
-                    external.add(import_path)
-            elif import_path.startswith("@"):
-                # Scoped package
-                parts = import_path.split("/")
-                pkg = "/".join(parts[:2]) if len(parts) >= 2 else import_path
-                external.add(pkg)
-            else:
-                external.add(import_path.split("/")[0])
+    Contract Kernel Cut Condition A: dispatches through the registry-DATA
+    strategy for ``language`` (no ``if language ==`` branch here). The strategy
+    also applies the per-language stdlib subtraction, byte-identical to the
+    former inline ``external -= _common_stdlib(language)`` tail.
+    """
+    from codd.parsing.regex_strategies import strategy_for
 
-    elif language == "go":
-        in_import = False
-        for line in content.splitlines():
-            if re.match(r'^import\s*\(', line):
-                in_import = True
-                continue
-            if in_import and line.strip() == ")":
-                in_import = False
-                continue
-            if in_import or re.match(r'^import\s+"', line):
-                m = re.search(r'"([^"]+)"', line)
-                if m:
-                    pkg = m.group(1)
-                    external.add(pkg.split("/")[-1])
+    return strategy_for(language).imports(content, project_root, src_dir, file_path)
 
-    # Remove stdlib-like imports from external
-    external -= _common_stdlib(language)
 
-    return internal, external
+def _common_stdlib(language: str) -> set[str]:
+    """Return common stdlib modules to exclude from external imports.
 
+    Registry-data lookup (no language-name branch); empty for languages with no
+    declared stdlib set, byte-identical to the former python-only ladder.
+    """
+    from codd.parsing.regex_strategies import common_stdlib
 
-def _common_stdlib(language: str) -> set[str]:
-    """Return common stdlib modules to exclude from external imports."""
-    if language == "python":
-        return {
-            "os", "sys", "re", "json", "math", "time", "datetime", "pathlib",
-            "typing", "collections", "itertools", "functools", "copy", "io",
-            "subprocess", "shutil", "tempfile", "hashlib", "uuid", "logging",
-            "unittest", "dataclasses", "enum", "abc", "contextlib", "textwrap",
-            "argparse", "configparser", "csv", "sqlite3", "http", "urllib",
-            "threading", "multiprocessing", "socket", "email", "html", "xml",
-            "importlib", "inspect", "ast", "dis", "warnings", "traceback",
-            "pprint", "string", "struct", "array", "queue", "heapq", "bisect",
-            "statistics", "random", "secrets", "base64", "binascii", "codecs",
-            "locale", "gettext", "calendar", "zlib", "gzip", "tarfile", "zipfile",
-            "__future__", "builtins", "types", "operator", "fnmatch", "glob",
-            "signal", "mmap", "ctypes", "platform", "sysconfig", "site",
-            "concurrent", "asyncio", "selectors", "ssl", "ftplib", "smtplib",
-        }
-    return set()
+    return common_stdlib(language)
 
 
 def _map_tests_to_modules(facts: ProjectFacts, project_root: Path,
@@ -706,19 +572,19 @@ def _map_tests_to_modules(facts: ProjectFacts, project_root: Path,
 
 
 def _guess_test_target(test_filename: str, language: str) -> str | None:
-    """Guess which module a test file targets from its name."""
-    name = Path(test_filename).stem
+    """Guess which module a test file targets from its name.
 
-    if language == "python":
-        # test_foo.py → foo
-        if name.startswith("test_"):
-            return name[5:]
-    elif language in ("typescript", "javascript"):
-        # foo.test.ts → foo, foo.spec.ts → foo
-        for suffix in (".test", ".spec"):
-            if name.endswith(suffix):
-                return name[: -len(suffix)]
+    Contract Kernel Cut Condition A: dispatches through the registry-DATA
+    strategy's ``guess_test_target`` rule (no ``if language ==`` branch);
+    languages without a rule return ``None``, byte-identical to the former
+    ladder.
+    """
+    from codd.parsing.regex_strategies import strategy_for
 
+    name = Path(test_filename).stem
+    rule = strategy_for(language).guess_test_target
+    if rule is not None:
+        return rule(name)
     return None
 
 
@@ -818,54 +684,28 @@ def _detect_go_patterns(facts: ProjectFacts, content: str):
 
 
 def _detect_code_patterns(mod: ModuleInfo, content: str, language: str):
-    """Detect API routes, DB models, page routes, auth redirects from source code."""
-    if language == "python":
-        if re.search(r'@(?:app|router)\.(get|post|put|delete|patch)\s*\(', content):
-            mod.patterns["api_routes"] = "HTTP route handlers"
-        if re.search(r'class\s+\w+\(.*(?:Base|Model|db\.Model)\)', content):
-            mod.patterns["db_models"] = "ORM models"
-        if re.search(r'@(?:celery_app|app)\.task', content):
-            mod.patterns["background_tasks"] = "Async task handlers"
-        if re.search(r'(?:redirect|RedirectResponse|HttpResponseRedirect)\s*\(', content):
-            mod.patterns["auth_redirects"] = "Server-side redirects"
-        if re.search(r'@login_required|@permission_required|LoginRequiredMixin', content):
-            mod.patterns["auth_guards"] = "Authentication guards"
-
-    elif language in ("typescript", "javascript"):
-        if re.search(r'(?:app|router)\.(get|post|put|delete|patch)\s*\(', content):
-            mod.patterns["api_routes"] = "HTTP route handlers"
-        if re.search(r'@(?:Controller|Get|Post|Put|Delete|Patch)\s*\(', content):
-            mod.patterns["api_routes"] = "NestJS controller"
-        if re.search(r'(?:schema|model)\s*\(', content, re.IGNORECASE):
-            mod.patterns["db_models"] = "Database models"
-        # Page routes: Next.js/Remix/SvelteKit page components with server-side logic
-        if re.search(r'export\s+default\s+(?:async\s+)?function\s+\w*Page', content):
-            mod.patterns["page_routes"] = "Page route components"
-        # Auth redirects: server-side redirect after auth checks
-        if re.search(r'(?:redirect|NextResponse\.redirect|Response\.redirect)\s*\(', content):
-            mod.patterns["auth_redirects"] = "Server-side redirects"
-        # Middleware with auth/redirect logic
-        if re.search(r'export\s+(?:async\s+)?function\s+middleware', content):
-            mod.patterns["middleware"] = "Request middleware"
-        # Client-side navigation: programmatic redirects after form submission
-        if re.search(r'(?:router\.push|router\.replace|window\.location\.assign|window\.location\.href\s*=)', content):
-            mod.patterns["client_redirects"] = "Client-side navigation"
-        # Auth provider configuration (NextAuth, Auth.js, etc.)
-        if re.search(r'(?:NextAuth|CredentialsProvider|signIn|signOut|useSession|getServerSession)', content):
-            mod.patterns["auth_provider"] = "Authentication provider"
+    """Detect API routes, DB models, page routes, auth redirects from source code.
+
+    Contract Kernel Cut Condition A: dispatches through the registry-DATA
+    strategy for ``language`` (no ``if language ==`` branch here). The
+    per-language detection bodies live in the strategy table; behaviour is
+    byte-identical to the former inline ladder.
+    """
+    from codd.parsing.regex_strategies import strategy_for
+
+    strategy_for(language).code_patterns(mod, content)
 
 
 def _detect_entry_points(facts: ProjectFacts, project_root: Path, language: str):
-    """Find likely entry points (main files)."""
-    candidates = {
-        "python": ["main.py", "app.py", "manage.py", "wsgi.py", "asgi.py", "__main__.py"],
-        "typescript": ["index.ts", "main.ts", "app.ts", "server.ts"],
-        "javascript": ["index.js", "main.js", "app.js", "server.js"],
-        "java": ["Application.java", "Main.java", "App.java"],
-        "go": ["main.go", "cmd/main.go"],
-    }
+    """Find likely entry points (main files).
+
+    Contract Kernel Cut Condition A: the per-language candidate list comes from
+    the registry-DATA strategy (no language-name keyed dict in core).
+    Byte-identical.
+    """
+    from codd.parsing.regex_strategies import entry_point_candidates
 
-    for candidate in candidates.get(language, []):
+    for candidate in entry_point_candidates(language):
         for src_dir in facts.source_dirs:
             path = project_root / src_dir / candidate
             if path.exists():

{codd_dev-2.86.0 → codd_dev-2.88.0}/codd/implementer.py

@@ -747,7 +747,10 @@ def _confusable_code_error(relative_path: str, content: str, *, language: str) -
     deterministic, no LLM calls.
     """
     suffix = PurePosixPath(relative_path).suffix.lower()
-    is_python = suffix == ".py" or (suffix == "" and language == "python")
+    # "is this a Python payload" is driven from the language's declared
+    # extensions (DATA), not a ``language == "python"`` branch: a .py suffix, or
+    # an extensionless payload whose language declares .py as a source extension.
+    is_python = suffix == ".py" or (suffix == "" and ".py" in _implementation_language_extensions(language))
     if not is_python:
         return None
     findings = _confusable_findings(content)
@@ -1754,7 +1757,7 @@ def _candidate_generated_paths(spec: ImplementSpec, language: Any, design_conten
         candidates.append(PurePosixPath(output_path) / f"index{default_extension}")
 
     normalized_language = _normalize_implementation_language(language)
-    if normalized_language in {"typescript", "javascript"} and _spec_looks_ui_facing(spec, design_content):
+    if _ui_variant_extension(normalized_language) is not None and _spec_looks_ui_facing(spec, design_content):
         extensions = _implementation_language_extensions(normalized_language)
         if len(extensions) > 1:
             for output_path in spec.output_paths:
@@ -1883,7 +1886,7 @@ def _build_implementation_prompt(
     else:
         framework_guidance = f"- Use idiomatic {language_name} patterns for the target project."
 
-    if language in {"typescript", "javascript"} and len(preferred_extensions) > 1:
+    if _ui_variant_extension(language) is not None and len(preferred_extensions) > 1:
         jsx_extension = preferred_extensions[1]
         extension_guidance = (
             f"- If the work needs JSX-style UI components, emit {jsx_extension} files. "
@@ -2581,10 +2584,41 @@ def _implementation_language_extensions(language: Any) -> tuple[str, ...]:
     return LANGUAGE_EXT_MAP.get(normalized, LANGUAGE_EXT_MAP["typescript"])
 
 
+#: Registry DATA (Contract Kernel Cut Condition A — implementer.py): the SECOND
+#: extension some language families carry is a JSX/UI-COMPONENT variant
+#: (TypeScript's ``.tsx``, JavaScript's ``.jsx``) rather than just "another file
+#: type" (e.g. C++'s ``.cc``/``.h``). Only a family whose alt extension is a UI
+#: variant should route UI-facing work to ``extensions[1]``. This is a
+#: language→capability DATA table (the analogue of a profile/registry entry — a
+#: declared capability, NOT a core ``language in (...)`` branch); core code asks
+#: ``_ui_variant_extension(language) is not None`` (a capability flag), never a
+#: language name. Byte-identical to the former ``in {"typescript","javascript"}``
+#: guards: those two families are exactly the ones whose ``extensions[1]`` is the
+#: UI/JSX variant.
+_UI_VARIANT_EXTENSION_BY_LANGUAGE: dict[str, str] = {
+    "typescript": ".tsx",
+    "javascript": ".jsx",
+}
+
+
+def _ui_variant_extension(language: Any) -> str | None:
+    """The language's JSX/UI-component variant extension, or ``None`` (data lookup).
+
+    A capability flag in DATA form: a language family declares whether it has a
+    dedicated UI-component extension (``.tsx``/``.jsx``). ``None`` means the
+    family has no UI variant (its ``extensions[1]``, if any, is just another file
+    type), so UI-facing routing must NOT use the alternate extension. Replaces
+    the former ``language in {"typescript","javascript"}`` dispatch.
+    """
+    normalized = _normalize_implementation_language(language)
+    return _UI_VARIANT_EXTENSION_BY_LANGUAGE.get(normalized)
+
+
 def _default_generated_extension(language: Any, content: str | None = None) -> str:
     normalized = _normalize_implementation_language(language)
     extensions = _implementation_language_extensions(normalized)
-    if normalized in {"typescript", "javascript"} and len(extensions) > 1 and content and _looks_like_tsx(content):
+    ui_variant = _ui_variant_extension(normalized)
+    if ui_variant is not None and len(extensions) > 1 and content and _looks_like_tsx(content):
         return extensions[1]
     return extensions[0]
 

{codd_dev-2.86.0 → codd_dev-2.88.0}/codd/parsing/__init__.py

@@ -166,30 +166,18 @@ from codd.parsing.filesystem_routes import (
 
 
 def get_extractor(language: str, category: str = "source") -> LanguageExtractor:
-    """Select the best available extractor for a language/category pair."""
-    normalized_language = language.lower()
-    normalized_category = category.lower()
+    """Select the best available extractor for a language/category pair.
 
-    if normalized_category == "schema":
-        if normalized_language == "sql":
-            if SqlDdlExtractor.is_available():
-                return SqlDdlExtractor()
-            return RegexExtractor(normalized_language, normalized_category)
-        if normalized_language == "prisma":
-            return PrismaSchemaExtractor()
-        return RegexExtractor(normalized_language, normalized_category)
+    Contract Kernel Cut Condition A: selection is REGISTRY-DATA-driven (see
+    :mod:`codd.parsing.extractor_registry`) — the language NAMES live in a data
+    table, the core dispatches by a table lookup, NOT a ``if language ==``
+    ladder. Falls through to :class:`RegexExtractor` (best-effort analysis) for
+    any unknown/unsupported language. Behaviour is byte-identical to the former
+    inline ladder.
+    """
+    from codd.parsing.extractor_registry import select_extractor
 
-    if normalized_category == "source" and normalized_language == "python":
-        return PythonAstExtractor(normalized_language, normalized_category)
-
-    if (
-        normalized_category == "source"
-        and normalized_language in _TREE_SITTER_LANGUAGE_PACKAGES
-        and TreeSitterExtractor.is_available(normalized_language)
-    ):
-        return TreeSitterExtractor(normalized_language, normalized_category)
-
-    return RegexExtractor(normalized_language, normalized_category)
+    return select_extractor(language, category)
 
 
 __all__ = [

codd_dev-2.88.0/codd/parsing/extractor_registry.py

@@ -0,0 +1,120 @@
+"""Registry-DATA-driven extractor SELECTION for ``get_extractor``.
+
+Contract Kernel Cut Condition A (PARSING/EXTRACTION zone). ``get_extractor``
+used to select a backend with a ``if normalized_language == "python"`` /
+``in _TREE_SITTER_LANGUAGE_PACKAGES`` ladder. This module replaces that with a
+DATA table of :class:`ExtractorSpec` entries: the core ``get_extractor`` iterates
+the table and picks the first spec whose ``(category, language)`` matches AND
+whose capability probe (``available``) is satisfied — NO ``if language ==``
+branch in the selection function.
+
+This registry is deliberately BROADER than the greenfield ``default_registry``
+(go/python/typescript): the extraction engine analyses many languages (python,
+ts, js, go, java, sql, prisma, …), so it must NOT be coupled to the 3 greenfield
+profiles. The language NAMES live here in the DATA table, which is the allowed
+"registry data" zone (v2.76: "project detection uses registry data").
+
+Capability probes keep graceful degradation intact: a tree-sitter / sql backend
+whose optional dependency is missing simply does not match, and selection falls
+through to the next spec and finally to :class:`RegexExtractor` (legitimate
+best-effort analysis — extraction is NOT a green/red gate).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Callable
+
+from codd.parsing._shared import LanguageExtractor, RegexExtractor
+
+
+@dataclass(frozen=True)
+class ExtractorSpec:
+    """One selectable extractor backend (registry DATA, not name dispatch).
+
+    * ``categories`` / ``languages`` — the ``(category, language)`` pairs this
+      spec serves (the NAMES that legitimately live in registry data).
+    * ``available`` — capability probe (e.g. tree-sitter binding importable);
+      ``None`` means always available.
+    * ``factory`` — builds the extractor for a ``(language, category)`` pair.
+    """
+
+    categories: frozenset[str]
+    languages: frozenset[str]
+    factory: Callable[[str, str], LanguageExtractor]
+    available: Callable[[str], bool] | None = None
+
+    def matches(self, language: str, category: str) -> bool:
+        if category not in self.categories or language not in self.languages:
+            return False
+        if self.available is not None and not self.available(language):
+            return False
+        return True
+
+
+def _build_specs() -> tuple[ExtractorSpec, ...]:
+    # Imported lazily inside the builder to avoid import cycles at package load
+    # (these backends import from ``_shared`` / each other).
+    from codd.parsing.python_ast import PythonAstExtractor
+    from codd.parsing.schemas import PrismaSchemaExtractor, SqlDdlExtractor
+    from codd.parsing.treesitter import (
+        _TREE_SITTER_LANGUAGE_PACKAGES,
+        TreeSitterExtractor,
+    )
+
+    return (
+        # ── schema category ──────────────────────────────────────────────
+        ExtractorSpec(
+            categories=frozenset({"schema"}),
+            languages=frozenset({"sql"}),
+            factory=lambda language, category: SqlDdlExtractor(),
+            available=lambda language: SqlDdlExtractor.is_available(),
+        ),
+        ExtractorSpec(
+            categories=frozenset({"schema"}),
+            languages=frozenset({"prisma"}),
+            factory=lambda language, category: PrismaSchemaExtractor(),
+        ),
+        # ── source category ──────────────────────────────────────────────
+        ExtractorSpec(
+            categories=frozenset({"source"}),
+            languages=frozenset({"python"}),
+            factory=lambda language, category: PythonAstExtractor(language, category),
+        ),
+        # Tree-sitter source backend: serves exactly the languages with a
+        # registered binding, gated by the per-language availability probe.
+        # NOTE: this mirrors the pre-refactor ladder EXACTLY, including that
+        # ``sql`` is a tree-sitter package (so ``get_extractor("sql","source")``
+        # selects tree-sitter when available) — byte-identical selection.
+        ExtractorSpec(
+            categories=frozenset({"source"}),
+            languages=frozenset(_TREE_SITTER_LANGUAGE_PACKAGES),
+            factory=lambda language, category: TreeSitterExtractor(language, category),
+            available=lambda language: TreeSitterExtractor.is_available(language),
+        ),
+    )
+
+
+_SPECS: tuple[ExtractorSpec, ...] | None = None
+
+
+def _specs() -> tuple[ExtractorSpec, ...]:
+    global _SPECS
+    if _SPECS is None:
+        _SPECS = _build_specs()
+    return _SPECS
+
+
+def select_extractor(language: str, category: str = "source") -> LanguageExtractor:
+    """Select the best available extractor via the registry-data table.
+
+    Iterates the DATA specs in priority order and returns the first match;
+    falls through to :class:`RegexExtractor` (best-effort analysis) when no
+    spec serves the ``(language, category)`` pair or the capability is missing.
+    """
+    normalized_language = (language or "").lower()
+    normalized_category = (category or "").lower()
+    for spec in _specs():
+        if spec.matches(normalized_language, normalized_category):
+            return spec.factory(normalized_language, normalized_category)
+    return RegexExtractor(normalized_language, normalized_category)