code-puppy 0.0.554__tar.gz → 0.0.556__tar.gz

{code_puppy-0.0.554 → code_puppy-0.0.556}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.554
+Version: 0.0.556
 Summary: Code generation agent
 Project-URL: repository, https://github.com/mpfaffenberger/code_puppy
 Project-URL: HomePage, https://github.com/mpfaffenberger/code_puppy

{code_puppy-0.0.554 → code_puppy-0.0.556}/code_puppy/claude_cache_client.py

@@ -42,13 +42,14 @@ CLAUDE_CLI_USER_AGENT = "claude-cli/2.1.2 (external, cli)"
 
 
 def _model_requires_thinking_summary(model_name):
-    # Anthropic's Opus 4.7 family rejects adaptive-thinking requests unless a
-    # 'display: summary' field is present alongside 'type: adaptive'. We check
-    # both naming conventions (opus-4-7 and 4-7-opus).
+    # Anthropic's Opus 4.7+ / Fable 5 families reject adaptive-thinking
+    # requests unless 'display: summarized' is present alongside
+    # 'type: adaptive'. Delegate to model_utils — single source of truth.
     if not model_name:
         return False
-    lower = model_name.lower()
-    return "opus-4-7" in lower or "4-7-opus" in lower
+    from code_puppy.model_utils import should_use_anthropic_thinking_summary
+
+    return should_use_anthropic_thinking_summary(model_name)
 
 
 def _enforce_thinking_display_summary(payload):

{code_puppy-0.0.554 → code_puppy-0.0.556}/code_puppy/model_utils.py

@@ -136,6 +136,8 @@ def supports_adaptive_thinking(
         "4-8-opus",
         "sonnet-4-6",
         "4-6-sonnet",
+        "fable-5",
+        "5-fable",
     )
     return any(tag in c for c in candidates for tag in _ADAPTIVE_TAGS)
 
@@ -145,7 +147,7 @@ def get_default_extended_thinking(
 ) -> str:
     """Return the default extended_thinking mode for an Anthropic model.
 
-    Opus 4-6, Opus 4-7, Opus 4-8, and Sonnet 4-6 models default to
+    Opus 4-6, Opus 4-7, Opus 4-8, Sonnet 4-6, and Fable 5 models default to
     ``"adaptive"`` thinking; all other Anthropic models default to ``"enabled"``.
 
     Args:
@@ -166,13 +168,18 @@ def should_use_anthropic_thinking_summary(
 ) -> bool:
     """Return whether Anthropic adaptive thinking should request summary display.
 
-    Anthropic's newer Opus 4.7 and 4.8 models require ``display: \"summarized\"``
-    alongside ``thinking={"type": "adaptive"}``.
+    Anthropic's newer Opus 4.7+, Opus 4.8, and Fable 5 models require
+    ``display: \"summarized\"`` alongside ``thinking={"type": "adaptive"}``.
     """
+    _SUMMARY_TAGS = (
+        "opus-4-7",
+        "4-7-opus",
+        "opus-4-8",
+        "4-8-opus",
+        "fable-5",
+        "5-fable",
+    )
     candidates = [model_name.lower()]
     if actual_model_id:
         candidates.append(actual_model_id.lower())
-    return any(
-        "opus-4-7" in c or "4-7-opus" in c or "opus-4-8" in c or "4-8-opus" in c
-        for c in candidates
-    )
+    return any(tag in c for c in candidates for tag in _SUMMARY_TAGS)

{code_puppy-0.0.554 → code_puppy-0.0.556}/code_puppy/plugins/agent_skills/discovery.py

@@ -235,6 +235,15 @@ def discover_skills(directories: Optional[List[Path]] = None) -> List[SkillInfo]
             if not skill_dir.is_dir() or skill_dir.name.startswith("."):
                 continue
 
+            # First-discovered skill wins - skip duplicates from later directories
+            if skill_dir.name in seen_skill_names:
+                logger.debug(
+                    "Skipping duplicate skill '%s' at %s (already discovered)",
+                    skill_dir.name,
+                    skill_dir,
+                )
+                continue
+
             has_skill_md = is_valid_skill_directory(skill_dir)
             skill_info = SkillInfo(
                 name=skill_dir.name,

{code_puppy-0.0.554 → code_puppy-0.0.556}/code_puppy/tools/ask_user_question/constants.py

@@ -6,7 +6,9 @@ from typing import Final
 MAX_QUESTIONS_PER_CALL: Final[int] = 10  # Reasonable limit for a single TUI interaction
 MIN_OPTIONS_PER_QUESTION: Final[int] = 2
 MAX_OPTIONS_PER_QUESTION: Final[int] = 6
-MAX_HEADER_LENGTH: Final[int] = 60
+MAX_HEADER_LENGTH: Final[int] = (
+    25  # Must fit in left panel (MAX_LEFT_PANEL_WIDTH - padding)
+)
 MAX_LABEL_LENGTH: Final[int] = 50
 MAX_DESCRIPTION_LENGTH: Final[int] = 200
 MAX_QUESTION_LENGTH: Final[int] = 500

code_puppy-0.0.556/code_puppy/tools/ask_user_question/registration.py

@@ -0,0 +1,157 @@
+"""Tool registration for ask_user_question."""
+
+from __future__ import annotations
+
+import json
+from typing import TYPE_CHECKING, Annotated, Any, Dict, List
+
+from pydantic import BeforeValidator, Field, WithJsonSchema
+from pydantic_ai import RunContext
+
+from .constants import (
+    MAX_DESCRIPTION_LENGTH,
+    MAX_HEADER_LENGTH,
+    MAX_LABEL_LENGTH,
+    MAX_OPTIONS_PER_QUESTION,
+    MAX_QUESTION_LENGTH,
+    MAX_QUESTIONS_PER_CALL,
+    MIN_OPTIONS_PER_QUESTION,
+)
+from .handler import ask_user_question as _ask_user_question_impl
+from .models import AskUserQuestionOutput
+
+if TYPE_CHECKING:
+    from pydantic_ai import Agent
+
+
+# Inline JSON schemas to avoid $defs/$ref that many LLM providers misinterpret.
+# This matches the approach used by replace_in_file for complex nested types.
+# Include maxLength constraints so LLMs know the limits upfront.
+_OPTION_SCHEMA: Dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "label": {
+            "type": "string",
+            "maxLength": MAX_LABEL_LENGTH,
+            "description": f"Short option name (1-5 words, max {MAX_LABEL_LENGTH} chars)",
+        },
+        "description": {
+            "type": "string",
+            "maxLength": MAX_DESCRIPTION_LENGTH,
+            "description": f"Optional explanation (max {MAX_DESCRIPTION_LENGTH} chars)",
+        },
+    },
+    "required": ["label"],
+}
+
+_QUESTION_SCHEMA: Dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "question": {
+            "type": "string",
+            "maxLength": MAX_QUESTION_LENGTH,
+            "description": f"The full question text (max {MAX_QUESTION_LENGTH} chars)",
+        },
+        "header": {
+            "type": "string",
+            "maxLength": MAX_HEADER_LENGTH,
+            "description": f"Short label for compact display (max {MAX_HEADER_LENGTH} chars, no spaces)",
+        },
+        "multi_select": {
+            "type": "boolean",
+            "description": "If true, user can select multiple options (default: false)",
+        },
+        "options": {
+            "type": "array",
+            "items": _OPTION_SCHEMA,
+            "minItems": MIN_OPTIONS_PER_QUESTION,
+            "maxItems": MAX_OPTIONS_PER_QUESTION,
+            "description": f"Array of {MIN_OPTIONS_PER_QUESTION}-{MAX_OPTIONS_PER_QUESTION} selectable options",
+        },
+    },
+    "required": ["question", "header", "options"],
+}
+
+_QUESTIONS_ARRAY_SCHEMA: Dict[str, Any] = {
+    "type": "array",
+    "items": _QUESTION_SCHEMA,
+    "minItems": 1,
+    "maxItems": MAX_QUESTIONS_PER_CALL,
+    "description": (
+        f"Array of 1-{MAX_QUESTIONS_PER_CALL} question objects. Each question needs: "
+        f"'question' (max {MAX_QUESTION_LENGTH} chars), "
+        f"'header' (max {MAX_HEADER_LENGTH} chars, no spaces), "
+        f"'options' (array of {MIN_OPTIONS_PER_QUESTION}-{MAX_OPTIONS_PER_QUESTION} options with 'label'). "
+        "Optional: 'multi_select' (boolean)."
+    ),
+}
+
+
+def _coerce_questions_json_string(v: Any) -> Any:
+    """Coerce a JSON-stringified array to a native list before pydantic validates it.
+
+    LLMs frequently pass the questions array as a JSON string (e.g. ``"[{...}]"``)
+    instead of a native list. pydantic-ai validates tool call arguments against
+    the function signature before calling the handler — so the coercion must
+    happen here, at the registration layer, before pydantic sees the value.
+
+    If JSON parsing fails, the original value is returned unchanged and pydantic
+    produces a clear type error.
+    """
+    if isinstance(v, str):
+        try:
+            return json.loads(v)
+        except (json.JSONDecodeError, ValueError):
+            return v
+    return v
+
+
+# Type alias with explicit JSON schema override so LLMs see the full structure.
+# The BeforeValidator handles JSON-string coercion before validation.
+# The WithJsonSchema tells pydantic to emit our inline schema instead of inferring.
+QuestionsListWithSchema = Annotated[
+    List[Dict[str, Any]],
+    BeforeValidator(_coerce_questions_json_string),
+    WithJsonSchema(_QUESTIONS_ARRAY_SCHEMA),
+    Field(
+        description=(
+            f"Array of 1-{MAX_QUESTIONS_PER_CALL} question objects. Each question needs: "
+            f"'question' (max {MAX_QUESTION_LENGTH} chars), "
+            f"'header' (max {MAX_HEADER_LENGTH} chars), "
+            f"'options' ({MIN_OPTIONS_PER_QUESTION}-{MAX_OPTIONS_PER_QUESTION} options with 'label')."
+        )
+    ),
+]
+
+
+def register_ask_user_question(agent: Agent) -> None:
+    """Register the ask_user_question tool with the given agent."""
+
+    @agent.tool
+    def ask_user_question(
+        context: RunContext,  # noqa: ARG001 - Required by framework
+        questions: QuestionsListWithSchema,
+    ) -> AskUserQuestionOutput:
+        """Ask the user multiple related questions in an interactive TUI."""
+        # Keep the external tool schema simple for provider compatibility.
+        # The handler performs the real nested validation and normalization.
+        # Fire a Claude Code-style notification so plugins can react when the
+        # agent is awaiting user input.
+        try:
+            import asyncio as _asyncio
+
+            from code_puppy.callbacks import on_notification
+
+            _coro = on_notification(
+                "Agent is waiting for user input",
+                level="prompt",
+                context={"questions": questions},
+            )
+            try:
+                _asyncio.get_running_loop()
+                _asyncio.ensure_future(_coro)
+            except RuntimeError:
+                _asyncio.run(_coro)
+        except Exception:
+            pass
+        return _ask_user_question_impl(questions)

{code_puppy-0.0.554 → code_puppy-0.0.556}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "code-puppy"
-version = "0.0.554"
+version = "0.0.556"
 description = "Code generation agent"
 readme = "README.md"
 requires-python = ">=3.11,<3.15"

code_puppy-0.0.554/code_puppy/tools/ask_user_question/registration.py

@@ -1,78 +0,0 @@
-"""Tool registration for ask_user_question."""
-
-from __future__ import annotations
-
-import json
-from typing import TYPE_CHECKING, Annotated, Any
-
-from pydantic import BeforeValidator, Field
-from pydantic_ai import RunContext
-
-from .handler import ask_user_question as _ask_user_question_impl
-from .models import AskUserQuestionOutput
-
-if TYPE_CHECKING:
-    from pydantic_ai import Agent
-
-
-def _coerce_questions_json_string(v: Any) -> Any:
-    """Coerce a JSON-stringified array to a native list before pydantic validates it.
-
-    LLMs frequently pass the questions array as a JSON string (e.g. ``"[{...}]"``)
-    instead of a native list. pydantic-ai validates tool call arguments against
-    the function signature before calling the handler — so the coercion must
-    happen here, at the registration layer, before pydantic sees the value.
-
-    If JSON parsing fails, the original value is returned unchanged and pydantic
-    produces a clear type error.
-    """
-    if isinstance(v, str):
-        try:
-            return json.loads(v)
-        except (json.JSONDecodeError, ValueError):
-            return v
-    return v
-
-
-def register_ask_user_question(agent: Agent) -> None:
-    """Register the ask_user_question tool with the given agent."""
-
-    @agent.tool
-    def ask_user_question(
-        context: RunContext,  # noqa: ARG001 - Required by framework
-        questions: Annotated[
-            list[dict[str, Any]],
-            BeforeValidator(_coerce_questions_json_string),
-            Field(
-                description=(
-                    "Array of question objects. Each question should include: "
-                    "'question' (string), 'header' (short string), optional "
-                    "'multi_select' (boolean), and 'options' (array of option "
-                    "objects with 'label' and optional 'description')."
-                )
-            ),
-        ],
-    ) -> AskUserQuestionOutput:
-        """Ask the user multiple related questions in an interactive TUI."""
-        # Keep the external tool schema simple for provider compatibility.
-        # The handler performs the real nested validation and normalization.
-        # Fire a Claude Code-style notification so plugins can react when the
-        # agent is awaiting user input.
-        try:
-            import asyncio as _asyncio
-
-            from code_puppy.callbacks import on_notification
-
-            _coro = on_notification(
-                "Agent is waiting for user input",
-                level="prompt",
-                context={"questions": questions},
-            )
-            try:
-                _asyncio.get_running_loop()
-                _asyncio.ensure_future(_coro)
-            except RuntimeError:
-                _asyncio.run(_coro)
-        except Exception:
-            pass
-        return _ask_user_question_impl(questions)