cicaddy-github 0.1.0__tar.gz → 0.3.0__tar.gz

{cicaddy_github-0.1.0 → cicaddy_github-0.3.0}/Dockerfile

@@ -1,4 +1,4 @@
-FROM python:3.12-slim
+FROM python:3.14-slim
 
 WORKDIR /app
 

{cicaddy_github-0.1.0 → cicaddy_github-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cicaddy-github
-Version: 0.1.0
+Version: 0.3.0
 Summary: GitHub Actions plugin for cicaddy AI agent framework
 Project-URL: Homepage, https://github.com/redhat-community-ai-tools/cicaddy-action
 Project-URL: Repository, https://github.com/redhat-community-ai-tools/cicaddy-action.git

{cicaddy_github-0.1.0 → cicaddy_github-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "cicaddy-github"
-version = "0.1.0"
+version = "0.3.0"
 description = "GitHub Actions plugin for cicaddy AI agent framework"
 readme = "README.md"
 requires-python = ">=3.11"

{cicaddy_github-0.1.0 → cicaddy_github-0.3.0}/src/cicaddy_github/github_integration/agents.py

@@ -1,6 +1,8 @@
 """GitHub AI Agents for PR review and task execution."""
 
 import os
+import re
+import textwrap
 from typing import Any
 
 from cicaddy.agent.base import BaseAIAgent
@@ -16,6 +18,50 @@ logger = get_logger(__name__)
 
 BOT_COMMENT_MARKER_PR_REVIEW = "<!-- cicaddy-action:pr-review -->"
 
+# Pattern matches fenced code blocks (possibly indented by list nesting).
+_FENCED_CODE_BLOCK = re.compile(
+    r"^([ \t]*(?:`{3,}|~{3,})[^\n]*)\n(.*?)\n([ \t]*(?:`{3,}|~{3,}))[ \t]*$",
+    re.MULTILINE | re.DOTALL,
+)
+
+
+def dedent_code_blocks(text: str) -> str:
+    """Remove common leading whitespace from fenced code block content.
+
+    AI models often indent code block content to match surrounding list
+    indentation.  GitHub renders that whitespace literally, so we strip
+    the common prefix using ``textwrap.dedent`` while preserving relative
+    indentation within the block.
+    """
+
+    def _dedent(match: re.Match) -> str:
+        opener = match.group(1).lstrip()
+        content = match.group(2)
+        closer = match.group(3).lstrip()
+        return f"{opener}\n{textwrap.dedent(content)}\n{closer}"
+
+    return _FENCED_CODE_BLOCK.sub(_dedent, text)
+
+
+# Matches output wrapped in a single ```markdown ... ``` fence.
+_MARKDOWN_WRAPPER = re.compile(
+    r"^\s*```(?:markdown|md)\s*\n(.*?)\n\s*```\s*$",
+    re.DOTALL | re.IGNORECASE,
+)
+
+
+def strip_markdown_wrapper(text: str) -> str:
+    """Strip a wrapping ```markdown fence from the entire AI output.
+
+    Some models interpret ``output_format: markdown`` as "wrap the response
+    in a markdown code fence", which causes GitHub to render the comment as
+    a literal code block instead of formatted markdown.
+    """
+    m = _MARKDOWN_WRAPPER.match(text.strip())
+    if m:
+        return m.group(1)
+    return text
+
 
 class GitHubTaskAgent(BaseAIAgent):
     """AI Agent for scheduled tasks and changelog generation."""
@@ -254,7 +300,8 @@ Please provide your comprehensive analysis in markdown format.
         comment = f"{BOT_COMMENT_MARKER_PR_REVIEW}\n"
 
         if "ai_analysis" in analysis_result:
-            comment += analysis_result["ai_analysis"] + "\n"
+            cleaned = strip_markdown_wrapper(analysis_result["ai_analysis"])
+            comment += dedent_code_blocks(cleaned) + "\n"
 
         comment += (
             "\n<!-- cicaddy-footer -->\n---\n"

{cicaddy_github-0.1.0 → cicaddy_github-0.3.0}/tasks/pr_review.yml

@@ -69,6 +69,9 @@ constraints:
   - Assess test coverage implications
   - When reviewing code that uses external libraries, use Context7 tools to look up
     current API documentation and best practices
+  - All fenced code blocks (```) must start at column 0 with no leading whitespace,
+    even when inside list items. Content inside code blocks must not have extra
+    indentation from list nesting
 
 reasoning: chain_of_thought
 output_format: markdown

cicaddy_github-0.3.0/tests/unit/test_agents.py

@@ -0,0 +1,113 @@
+"""Tests for dedent_code_blocks and strip_markdown_wrapper in agents module."""
+
+from cicaddy_github.github_integration.agents import dedent_code_blocks, strip_markdown_wrapper
+
+
+class TestDedentCodeBlocks:
+    """Test code block dedenting for AI-generated markdown."""
+
+    def test_dedents_indented_code_block(self):
+        """Code block content indented by list nesting is dedented."""
+        text = (
+            "*   **Example:**\n"
+            "    ```diff\n"
+            "        --- a/file.txt\n"
+            "        +++ b/file.txt\n"
+            "        @@ -1,3 +1,4 @@\n"
+            "    ```"
+        )
+        result = dedent_code_blocks(text)
+        assert "```diff\n--- a/file.txt\n+++ b/file.txt" in result
+
+    def test_preserves_relative_indentation(self):
+        """Relative indentation within the code block is preserved."""
+        text = "    ```python\n        def foo():\n            return 42\n    ```"
+        result = dedent_code_blocks(text)
+        assert "```python\ndef foo():\n    return 42\n```" in result
+
+    def test_no_change_for_unindented_blocks(self):
+        """Already flush code blocks are unchanged."""
+        text = "```python\ndef foo():\n    return 42\n```"
+        result = dedent_code_blocks(text)
+        assert result == text
+
+    def test_multiple_code_blocks(self):
+        """Multiple code blocks in the same text are all dedented."""
+        text = (
+            "Item 1:\n"
+            "    ```python\n"
+            "        print('a')\n"
+            "    ```\n"
+            "\n"
+            "Item 2:\n"
+            "    ```bash\n"
+            "        echo hello\n"
+            "    ```"
+        )
+        result = dedent_code_blocks(text)
+        assert "```python\nprint('a')\n```" in result
+        assert "```bash\necho hello\n```" in result
+
+    def test_tilde_delimiters(self):
+        """Tilde-fenced code blocks are also dedented."""
+        text = "    ~~~python\n        print('hello')\n    ~~~"
+        result = dedent_code_blocks(text)
+        assert "~~~python\nprint('hello')\n~~~" in result
+
+    def test_trailing_whitespace_on_closer(self):
+        """Trailing whitespace after closing fence is tolerated."""
+        text = "    ```python\n        x = 1\n    ```   "
+        result = dedent_code_blocks(text)
+        assert "```python\nx = 1\n```" in result
+
+    def test_text_without_code_blocks(self):
+        """Plain text without code blocks is unchanged."""
+        text = "This is plain markdown with **bold** and *italic*."
+        assert dedent_code_blocks(text) == text
+
+    def test_mixed_content_preserves_surrounding_text(self):
+        """List structure around code blocks is preserved."""
+        text = "* Item one\n    ```diff\n        +added line\n    ```\n* Item two"
+        result = dedent_code_blocks(text)
+        assert result.startswith("* Item one\n")
+        assert result.endswith("* Item two")
+        assert "+added line" in result
+
+
+class TestStripMarkdownWrapper:
+    """Test stripping wrapping ```markdown fences from AI output."""
+
+    def test_strips_markdown_wrapper(self):
+        """Output wrapped in ```markdown is unwrapped."""
+        text = "```markdown\n### Summary\nSome analysis.\n```"
+        result = strip_markdown_wrapper(text)
+        assert result == "### Summary\nSome analysis."
+
+    def test_strips_md_wrapper(self):
+        """Output wrapped in ```md is also unwrapped."""
+        text = "```md\n## Title\nContent.\n```"
+        result = strip_markdown_wrapper(text)
+        assert result == "## Title\nContent."
+
+    def test_strips_case_insensitive(self):
+        """Output wrapped in ```Markdown or ```MD is also unwrapped."""
+        for tag in ("Markdown", "MARKDOWN", "MD", "Md"):
+            text = f"```{tag}\nContent here.\n```"
+            result = strip_markdown_wrapper(text)
+            assert result == "Content here.", f"Failed for tag: {tag}"
+
+    def test_no_change_without_wrapper(self):
+        """Plain markdown without wrapper is unchanged."""
+        text = "### Summary\nSome analysis."
+        assert strip_markdown_wrapper(text) == text
+
+    def test_preserves_internal_code_blocks(self):
+        """Code blocks inside the markdown wrapper are preserved."""
+        text = "```markdown\n### Example\n```python\nprint('hi')\n```\n```"
+        result = strip_markdown_wrapper(text)
+        assert "```python\nprint('hi')\n```" in result
+
+    def test_no_change_for_non_markdown_fence(self):
+        """A ```python wrapper is NOT stripped."""
+        text = "```python\nprint('hi')\n```"
+        assert strip_markdown_wrapper(text) == text