codd-dev 2.54.0__tar.gz → 2.56.0__tar.gz

{codd_dev-2.54.0 → codd_dev-2.56.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codd-dev
-Version: 2.54.0
+Version: 2.56.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.54.0 → codd_dev-2.56.0}/codd/__init__.py

@@ -1,3 +1,3 @@
 """CoDD — Coherence-Driven Development."""
 
-__version__ = "2.54.0"
+__version__ = "2.56.0"

{codd_dev-2.54.0 → codd_dev-2.56.0}/codd/planner.py

@@ -421,8 +421,9 @@ def plan_init(
         prompt = _build_brownfield_plan_init_prompt(config, extracted_documents, capabilities)
 
     prompt = generator_module._inject_lexicon(prompt, project_root)
-    raw_wave_config = generator_module._invoke_ai_command(resolved_ai_command, prompt)
-    wave_config = _parse_wave_config_output(raw_wave_config)
+    wave_config = _invoke_and_parse_wave_config(
+        resolved_ai_command, prompt, max_retries=_plan_init_max_retries(config)
+    )
 
     from codd.config import find_codd_dir
     config["wave_config"] = wave_config
@@ -1119,6 +1120,68 @@ def _build_brownfield_plan_init_prompt(
     return "\n".join(lines).rstrip() + "\n"
 
 
+#: Bounded re-invocations when the AI returns an unparseable wave_config.
+#: Overridable per project via `plan.init_retry.max_retries` in codd.yaml.
+DEFAULT_PLAN_INIT_MAX_RETRIES = 2
+
+
+def _plan_init_max_retries(config: dict[str, Any]) -> int:
+    """Read `plan.init_retry.max_retries` (default 2; 0 disables the retry loop)."""
+
+    plan_cfg = config.get("plan")
+    if isinstance(plan_cfg, dict):
+        retry_cfg = plan_cfg.get("init_retry")
+        if isinstance(retry_cfg, dict):
+            value = retry_cfg.get("max_retries")
+            if isinstance(value, int) and value >= 0:
+                return value
+    return DEFAULT_PLAN_INIT_MAX_RETRIES
+
+
+def _append_wave_config_retry_feedback(prompt: str, error: str) -> str:
+    """Re-state the strict-YAML contract after a parse failure, for the next attempt."""
+
+    note = (
+        "\n\n---\n"
+        "YOUR PREVIOUS RESPONSE WAS REJECTED: it could not be parsed as valid wave_config "
+        f"YAML ({error}). Output ONLY the wave_config mapping as STRICT, valid YAML — no "
+        "prose, no Markdown fences, no arrows (`->`) or annotations. Every key must be "
+        "followed by a colon and a value, and every list item must start with `- `. "
+        "Re-emit the COMPLETE wave_config now."
+    )
+    return prompt + note
+
+
+def _invoke_and_parse_wave_config(
+    ai_command: str, base_prompt: str, *, max_retries: int = DEFAULT_PLAN_INIT_MAX_RETRIES
+) -> dict[str, list[dict[str, Any]]]:
+    """Invoke the AI for a wave_config with a bounded parse-feedback retry loop.
+
+    A weaker model can emit syntactically malformed YAML (a stray ``-> `` arrow, a
+    key with no colon) that no generic textual sanitization can repair. Hard-failing
+    the whole plan stage on a single bad response violates the weakest-model
+    principle — a strong model masks the gap a weak one exposes. So each retry feeds
+    the parse error back to the model (mirrors generator._generate_document_body).
+    Infra failures (``AI command failed``) propagate immediately; exhausted retries
+    re-raise the last parse error unchanged (backward compat).
+    """
+
+    last_error: ValueError | None = None
+    feedback: str | None = None
+    for _attempt in range(max(0, max_retries) + 1):
+        prompt = base_prompt if feedback is None else _append_wave_config_retry_feedback(base_prompt, feedback)
+        try:
+            raw = generator_module._invoke_ai_command(ai_command, prompt)
+            return _parse_wave_config_output(raw)
+        except ValueError as exc:
+            if str(exc).startswith("AI command failed"):
+                raise  # infra failure: retrying the same broken command cannot help
+            last_error = exc
+            feedback = str(exc)
+    assert last_error is not None
+    raise last_error
+
+
 def _parse_wave_config_output(raw_output: str) -> dict[str, list[dict[str, Any]]]:
     """Parse an AI command's stdout into a validated wave_config mapping.
 

{codd_dev-2.54.0 → codd_dev-2.56.0}/codd/vb_marker_authenticity.py

@@ -921,6 +921,10 @@ _PY_DIRECT_IGNORED_NAMES = frozenset(
         "Exception",
         "BaseException",
         "AssertionError",
+        # the ``raise`` keyword: in the lexical (syntax-error) fallback path, a
+        # ``raise AssertionError("constant")`` must not look like it carries an
+        # observation name — without this it would mis-credit as a non-constant direct.
+        "raise",
         "ValueError",
         "TypeError",
         "RuntimeError",
@@ -1017,17 +1021,39 @@ def _py_callee_name(node: ast.AST) -> str:
     return ""
 
 
+def _is_py_assertion_error_raise(node: ast.AST) -> bool:
+    """Whether ``node`` is ``raise AssertionError`` / ``raise AssertionError(...)``.
+
+    ``assert cond, msg`` IS ``if not cond: raise AssertionError(msg)``, so an explicit
+    ``raise AssertionError(...)`` is a primitive assertion (the same family as the
+    already-recognized ``pytest.fail()``). Restricted to ``AssertionError`` ON PURPOSE:
+    a bare ``raise``/``raise err``/``raise ValueError(...)`` is exception re-raise or
+    error propagation, NOT an assertion — crediting those would widen the false-GREEN
+    surface. Aliased / ``builtins.AssertionError`` forms are intentionally out of scope
+    (alias tracking exceeds this false-RED fix).
+    """
+
+    if not isinstance(node, ast.Raise) or node.exc is None:
+        return False
+    exc = node.exc
+    if isinstance(exc, ast.Call):
+        exc = exc.func
+    return isinstance(exc, ast.Name) and exc.id == "AssertionError"
+
+
 def _is_py_primitive_assert_node(node: ast.AST) -> bool:
     """Whether ``node`` is a PRIMITIVE python assertion (mirrors ``_PY_PRIMITIVE_ASSERT_RE``).
 
-    An ``assert`` statement, a ``with pytest.raises(...)`` block, or an expression
-    statement calling ``pytest.fail`` / ``self.fail`` / ``self.assert*`` /
-    ``np.testing.assert*``. A bare call to a NAMED helper is NOT primitive (it is
-    resolved via the evidence graph), so it is not matched here.
+    An ``assert`` statement, ``raise AssertionError(...)``, a ``with pytest.raises(...)``
+    block, or an expression statement calling ``pytest.fail`` / ``self.fail`` /
+    ``self.assert*`` / ``np.testing.assert*``. A bare call to a NAMED helper is NOT
+    primitive (it is resolved via the evidence graph), so it is not matched here.
     """
 
     if isinstance(node, ast.Assert):
         return True
+    if _is_py_assertion_error_raise(node):
+        return True
     if isinstance(node, (ast.With, ast.AsyncWith)):
         for item in node.items:
             expr = item.context_expr
@@ -1045,6 +1071,22 @@ def _is_py_primitive_assert_node(node: ast.AST) -> bool:
     return False
 
 
+def _python_body_has_primitive_assertion(body_text: str) -> bool:
+    """AST-first ``has_assertion`` for a python test body.
+
+    Prefer the AST (``_is_py_primitive_assert_node``) so a primitive token sitting in
+    a STRING or COMMENT (e.g. ``x = "raise AssertionError(y)"``) does not spuriously
+    set ``has_assertion`` — which would otherwise reach the fail-open direct-evidence
+    path and become a false-GREEN. Falls back to the regex only when the body is not
+    parseable in isolation (mirrors the line-scanner fallback elsewhere)."""
+
+    try:
+        tree = ast.parse(textwrap.dedent(body_text))
+    except (SyntaxError, ValueError):
+        return bool(_PY_PRIMITIVE_ASSERT_RE.search(body_text))
+    return any(_is_py_primitive_assert_node(node) for node in ast.walk(tree))
+
+
 #: Python standard-library top-level module names (PEP-official frozenset; includes
 #: platform-specific and disabled modules). Used to POSITIVELY classify a stdlib
 #: import as a library reference. Absence here never forces a verdict (fail-open).
@@ -1488,7 +1530,12 @@ _PY_SKIP_DECORATOR_RE = re.compile(
 #: is resolved via the evidence graph so a no-op helper cannot pass on its name.
 _PY_PRIMITIVE_ASSERT_RE = re.compile(
     r"(^|[^A-Za-z0-9_])(assert\b|pytest\.raises\b|pytest\.fail\s*\(|"
-    r"self\.assert[A-Za-z]+\s*\(|self\.fail\s*\(|np\.testing\.assert)",
+    r"self\.assert[A-Za-z]+\s*\(|self\.fail\s*\(|np\.testing\.assert)"
+    # ``raise AssertionError`` (the explicit form of ``assert``) — LINE-ANCHORED so a
+    # ``raise AssertionError`` inside a string/comment does not match (the AST-first
+    # ``_python_body_has_primitive_assertion`` is the primary guard; this is fallback).
+    r"|^[ \t]*raise\s+AssertionError\b",
+    re.MULTILINE,
 )
 #: A python ``def helper(...):`` header (captures name + the parameter list so the
 #: argument-anchor check can confirm the helper references its own arguments).
@@ -1605,7 +1652,7 @@ class PythonTestBlockProfile:
             decorator_text = "\n".join(lines[start_line - 1 : def_line - 1])
             if _PY_SKIP_DECORATOR_RE.search(decorator_text):
                 skipped = True
-            has_assertion = bool(_PY_PRIMITIVE_ASSERT_RE.search(body_text))
+            has_assertion = _python_body_has_primitive_assertion(body_text)
             blocks.append(
                 TestBlock(
                     start_line=start_line,
@@ -1672,7 +1719,7 @@ class PythonTestBlockProfile:
             decorator_text = "\n".join(lines[start_line - 1 : index])
             if _PY_SKIP_DECORATOR_RE.search(decorator_text):
                 skipped = True
-            has_assertion = bool(_PY_PRIMITIVE_ASSERT_RE.search(body_text))
+            has_assertion = _python_body_has_primitive_assertion(body_text)
             blocks.append(
                 TestBlock(
                     start_line=start_line,

{codd_dev-2.54.0 → codd_dev-2.56.0}/pyproject.toml

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