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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codd-dev
-Version: 2.87.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.87.0 → codd_dev-2.88.0}/codd/__init__.py

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

{codd_dev-2.87.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.87.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.87.0 → codd_dev-2.88.0}/codd/parsing/regex_strategies.py

@@ -529,6 +529,99 @@ def strategy_for(language: str) -> RegexLanguageStrategy:
     return _STRATEGIES.get((language or "").lower(), GENERIC_STRATEGY)
 
 
+# ─────────────────────────────────────────────────────────────────────────────
+# Repair-slice analyzer registry DATA (Contract Kernel Cut Condition A —
+# repair_slice.py de-literalization). ``codd/repair_slice.py``'s function
+# line-range + raises analyzer used to branch on ``language in
+# ("typescript","javascript")`` (tree-sitter func node-type set) and
+# ``language == "python"`` (regex def-vs-function pattern + group index, and the
+# python-only raises regex). Those per-language facts live HERE as registry DATA
+# (the analogue of a profile/adapter — an analyzer impl legitimately names its
+# own language), so the core analyzer dispatches by a data lookup, NOT a
+# language-name branch. Byte-identical to the former inline ladders; the
+# ``tests/languages/test_contract_kernel_cut_a_parity.py`` oracle pins this.
+#
+# Repair-slice extraction (like all extraction) is ANALYSIS input for patch
+# context, never a green/red GATE verdict — so an unknown language degrading to
+# the GENERIC profile (empty func-node set, the function-keyword regex, no raises)
+# is legitimate best-effort analysis, not a false-green.
+# ─────────────────────────────────────────────────────────────────────────────
+
+
+@dataclass(frozen=True)
+class RepairSliceLanguageProfile:
+    """Per-language repair-slice analyzer DATA (one language; not dispatch).
+
+    * ``function_node_types`` — the tree-sitter named-node types that are a
+      function/method definition for this language (walked for line ranges).
+    * ``line_range_pattern`` — the regex (with ``re.MULTILINE``) that matches a
+      function definition in the regex FALLBACK path.
+    * ``line_range_name_group`` — which regex group holds the function name.
+    * ``raises_def_pattern`` / ``raises_stmt_pattern`` — the regex pair for the
+      regex-fallback raises analyzer; ``None`` (the GENERIC default) means this
+      language contributes NO raises in the fallback (byte-identical to the
+      former ``if language != "python": return {}``).
+    """
+
+    function_node_types: frozenset[str] = frozenset({"function_definition"})
+    line_range_pattern: re.Pattern[str] = field(
+        default_factory=lambda: re.compile(
+            r"^\s*(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(", re.MULTILINE
+        )
+    )
+    line_range_name_group: int = 1
+    raises_def_pattern: re.Pattern[str] | None = None
+    raises_stmt_pattern: re.Pattern[str] | None = None
+
+
+#: The python repair-slice profile: tree-sitter walks only ``function_definition``
+#: (methods are ``function_definition`` inside a class in the python grammar); the
+#: regex fallback uses the ``def`` pattern with the NAME in group 2; and python is
+#: the ONLY language with a regex raises analyzer.
+_REPAIR_PYTHON = RepairSliceLanguageProfile(
+    function_node_types=frozenset({"function_definition"}),
+    line_range_pattern=re.compile(r"^(\s*)(?:async\s+)?def\s+(\w+)\s*\(", re.MULTILINE),
+    line_range_name_group=2,
+    raises_def_pattern=re.compile(r"\s*(?:async\s+)?def\s+(\w+)\s*\("),
+    raises_stmt_pattern=re.compile(r"\s+raise\s+(\w+)"),
+)
+
+#: The ts/js repair-slice profile: tree-sitter additionally walks
+#: ``method_definition`` + ``function_declaration`` (the former ``language in
+#: ("typescript","javascript")`` set); the regex fallback uses the
+#: ``function`` pattern with the NAME in group 1; no regex raises analyzer.
+_REPAIR_TS_JS = RepairSliceLanguageProfile(
+    function_node_types=frozenset(
+        {"function_definition", "method_definition", "function_declaration"}
+    ),
+    line_range_pattern=re.compile(
+        r"^\s*(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(", re.MULTILINE
+    ),
+    line_range_name_group=1,
+)
+
+#: The GENERIC repair-slice profile for any other/unknown language — byte-identical
+#: to the former ``else`` branches: tree-sitter walks only ``function_definition``;
+#: the regex fallback uses the ``function`` pattern with the name in group 1; and
+#: no raises (the former ``if language != "python": return {}``).
+GENERIC_REPAIR_PROFILE = RepairSliceLanguageProfile()
+
+_REPAIR_PROFILES: dict[str, RepairSliceLanguageProfile] = {
+    "python": _REPAIR_PYTHON,
+    "typescript": _REPAIR_TS_JS,
+    "javascript": _REPAIR_TS_JS,
+}
+
+
+def repair_slice_profile_for(language: str) -> RepairSliceLanguageProfile:
+    """Repair-slice analyzer profile for *language* (registry-data lookup).
+
+    Unknown languages resolve to :data:`GENERIC_REPAIR_PROFILE` (the former
+    non-python / non-ts-js ``else`` behavior); analysis input, never a gate.
+    """
+    return _REPAIR_PROFILES.get((language or "").lower(), GENERIC_REPAIR_PROFILE)
+
+
 def language_extensions(language: str) -> set[str]:
     """Source-file extensions for *language* (registry-data lookup)."""
     return set(strategy_for(language).extensions)

{codd_dev-2.87.0 → codd_dev-2.88.0}/codd/repair_slice.py

@@ -60,9 +60,8 @@ def extract_function_line_ranges(
         ext = get_extractor(language)
         if not isinstance(ext, TreeSitterExtractor):
             return _extract_line_ranges_regex(content, language)
-        parser = ext._get_parser()
-        tree = parser.parse(content.encode("utf-8", errors="ignore"))
-        return _walk_functions_for_ranges(tree.root_node, content, language)
+        root = ext._parse(content)
+        return _walk_functions_for_ranges(root, content, language)
     except Exception:
         return _extract_line_ranges_regex(content, language)
 
@@ -72,12 +71,14 @@ def _walk_functions_for_ranges(
 ) -> dict[str, tuple[int, int]]:
     """Walk AST to find all function definitions with their line ranges."""
     from codd.parsing import _iter_named_nodes, _field_text
+    from codd.parsing.regex_strategies import repair_slice_profile_for
     content_bytes = content.encode("utf-8", errors="ignore")
     ranges: dict[str, tuple[int, int]] = {}
 
-    func_types = {"function_definition"}
-    if language in ("typescript", "javascript"):
-        func_types.update({"method_definition", "function_declaration"})
+    # The set of tree-sitter function/method node types for this language is
+    # registry DATA (the analogue of a profile/adapter), not a language-name
+    # branch in core. ts/js add method_definition + function_declaration.
+    func_types = repair_slice_profile_for(language).function_node_types
 
     for node in _iter_named_nodes(root):
         if node.type not in func_types:
@@ -105,18 +106,24 @@ def _parent_class_name(content_bytes: bytes, node: Any) -> str:
 
 
 def _extract_line_ranges_regex(content: str, language: str) -> dict[str, tuple[int, int]]:
-    """Fallback: regex-based line range extraction."""
-    ranges: dict[str, tuple[int, int]] = {}
-    if language == "python":
-        pattern = re.compile(r'^(\s*)(?:async\s+)?def\s+(\w+)\s*\(', re.MULTILINE)
-    else:
-        pattern = re.compile(r'^\s*(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(', re.MULTILINE)
+    """Fallback: regex-based line range extraction.
+
+    The def-vs-function regex and the name-capture group are registry DATA per
+    language (python uses ``def`` with name in group 2; every other language uses
+    ``function`` with name in group 1), so this core fallback dispatches by a
+    data lookup, not a ``language == "python"`` branch.
+    """
+    from codd.parsing.regex_strategies import repair_slice_profile_for
+    profile = repair_slice_profile_for(language)
+    pattern = profile.line_range_pattern
+    name_group = profile.line_range_name_group
 
+    ranges: dict[str, tuple[int, int]] = {}
     lines = content.split("\n")
     matches = list(pattern.finditer(content))
     for i, m in enumerate(matches):
         line_no = content[:m.start()].count("\n") + 1
-        name = m.group(2) if language == "python" else m.group(1)
+        name = m.group(name_group)
         # Estimate end: next function or end of file
         if i + 1 < len(matches):
             end_line = content[:matches[i + 1].start()].count("\n")
@@ -137,9 +144,8 @@ def extract_raises(content: str, file_path: str, language: str) -> dict[str, lis
         ext = get_extractor(language)
         if not isinstance(ext, TreeSitterExtractor):
             return _extract_raises_regex(content, language)
-        parser = ext._get_parser()
-        tree = parser.parse(content.encode("utf-8", errors="ignore"))
-        return _walk_raises(tree.root_node, content, language)
+        root = ext._parse(content)
+        return _walk_raises(root, content, language)
     except Exception:
         return _extract_raises_regex(content, language)
 
@@ -193,17 +199,27 @@ def _enclosing_function(content_bytes: bytes, node: Any) -> str:
 
 
 def _extract_raises_regex(content: str, language: str) -> dict[str, list[str]]:
-    """Fallback regex for raises extraction."""
+    """Fallback regex for raises extraction.
+
+    The def/raise regex pair is registry DATA per language; a language without a
+    declared raises analyzer (every language except python today) yields no
+    raises — a data lookup, not a ``language != "python"`` branch.
+    """
+    from codd.parsing.regex_strategies import repair_slice_profile_for
+    profile = repair_slice_profile_for(language)
+    def_pattern = profile.raises_def_pattern
+    stmt_pattern = profile.raises_stmt_pattern
+
     result: dict[str, list[str]] = {}
-    if language != "python":
+    if def_pattern is None or stmt_pattern is None:
         return result
     current_func = ""
     for line in content.split("\n"):
-        m = re.match(r'\s*(?:async\s+)?def\s+(\w+)\s*\(', line)
+        m = def_pattern.match(line)
         if m:
             current_func = m.group(1)
         if current_func:
-            rm = re.match(r'\s+raise\s+(\w+)', line)
+            rm = stmt_pattern.match(line)
             if rm:
                 exc = rm.group(1)
                 result.setdefault(current_func, [])

{codd_dev-2.87.0 → codd_dev-2.88.0}/codd/vb_marker_authenticity.py

@@ -1235,6 +1235,18 @@ def _python_body_assigned_names(body_text: str) -> set[str]:
     return names
 
 
+#: Poetry MANIFEST-FORMAT reserved keys that appear under
+#: ``[tool.poetry.dependencies]`` but are NOT third-party packages. Poetry stores
+#: the interpreter version constraint as a pseudo-dependency named ``python``
+#: (``python = "^3.11"``); it is the interpreter pin, not a distribution to
+#: import. This is a poetry FILE-FORMAT fact (the analogue of registry/profile
+#: DATA), NOT a target-language gate dispatch — the surrounding parser is already
+#: unconditionally Python-specific. Excluding it keeps the third-party set exact;
+#: membership here is byte-identical to the former inline ``k.lower() != "python"``
+#: filter (Contract Kernel Cut Condition A — vb_marker_authenticity.py).
+_POETRY_RESERVED_NON_DEPENDENCY_KEYS = frozenset({"python"})
+
+
 def _python_manifest_top_dependencies(project_root: Path | None) -> frozenset[str]:
     """Declared third-party dependency names from ``pyproject.toml`` (PEP 621 +
     poetry), normalized for top-module matching. Empty when absent/unparseable —
@@ -1268,7 +1280,11 @@ def _python_manifest_top_dependencies(project_root: Path | None) -> frozenset[st
     if isinstance(poetry, dict):
         pdeps = poetry.get("dependencies", {})
         if isinstance(pdeps, dict):
-            reqs.extend(k for k in pdeps if isinstance(k, str) and k.lower() != "python")
+            reqs.extend(
+                k
+                for k in pdeps
+                if isinstance(k, str) and k.lower() not in _POETRY_RESERVED_NON_DEPENDENCY_KEYS
+            )
     names: set[str] = set()
     for req in reqs:
         m = re.match(r"\s*([A-Za-z0-9._-]+)", req)

{codd_dev-2.87.0 → codd_dev-2.88.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "codd-dev"
-version = "2.87.0"
+version = "2.88.0"
 description = "CoDD: Coherence-Driven Development — cross-artifact change impact analysis"
 readme = "README.md"
 license = "MIT"