Test: xml_tagger wraps empty string in duplicate tags

[Serhan-Asad]

Bug

xml_tagger produces malformed output when given an empty string as content. When calling the tag function with content="", it wraps the empty string but produces duplicate closing tags.

Reproduction

from pdd.xml_tagger import wrap_xml
result = wrap_xml("test_tag", "")
# Expected: <test_tag></test_tag>
# Actual: <test_tag></test_tag></test_tag>

Failing Test

# tests/test_xml_tagger.py
def test_empty_content_wrapping():
    from pdd.xml_tagger import wrap_xml
    result = wrap_xml("test_tag", "")
    assert result == "<test_tag></test_tag>", f"Got: {result}"

Dev Unit

• Module: xml_tagger
• Prompt: prompts/xml_tagger_python.prompt
• Code: pdd/xml_tagger.py
• Test: tests/test_xml_tagger.py

[Serhan-Asad]

Step 1: Duplicate Check

Status: No duplicates found

Search Performed

• Searched for: xml_tagger, wrap_xml, duplicate tags, empty string, closing tags
• Issues reviewed: 15+ (across open and closed issues)

Findings

No existing issues reference xml_tagger, wrap_xml, or the duplicate closing tag behavior described in this issue. This appears to be a new, unique bug report.

---

Proceeding to Step 2: Documentation Check

[Serhan-Asad]

Step 2: Documentation Check

Status: Needs Investigation

Documentation Reviewed

• pdd/xml_tagger.py — module source code (only exports xml_tagger and main)
• tests/test_xml_tagger.py — existing test suite
• pdd/prompts/xml_tagger_python.prompt — prompt defining the module's interface
• CLAUDE.md, docs/ — project documentation

Findings

The reported function wrap_xml does not exist anywhere in the codebase:

1. pdd/xml_tagger.py only defines xml_tagger() (an LLM-based prompt enhancer) and main() — there is no wrap_xml function.
2. A codebase-wide search for wrap_xml across all files (including .prompt files) returned zero results.
3. The prompt file (xml_tagger_python.prompt) only specifies the xml_tagger function.
4. The existing xml_tagger() already handles empty strings by raising ValueError("raw_prompt must be a non-empty string") — this is tested and passing in test_empty_prompt.

The bug as described (wrap_xml("test_tag", "") producing duplicate closing tags) cannot be reproduced because the function doesn't exist. However, this may indicate:

• A missing utility function that should exist but was never implemented
• A reference to planned functionality from an architecture spec

Proceeding to investigate whether wrap_xml is defined elsewhere or expected by other modules.

---

Proceeding to Step 3: Triage

[Serhan-Asad]

Step 3: Triage

Status: Proceed

Summary

We have sufficient information to attempt reproduction, though with important caveats from Step 2:

1. Expected behavior is clear: wrap_xml("test_tag", "") should return <test_tag></test_tag>
2. Actual behavior is clear: it reportedly returns <test_tag></test_tag></test_tag> (duplicate closing tag)
3. Code area is identified: pdd/xml_tagger.py

Key finding from Step 2: The wrap_xml function referenced in the issue does not currently exist in the codebase. The pdd/xml_tagger.py module contains only xml_tagger() (an LLM-based prompt enhancer) and main(). The existing xml_tagger() already rejects empty strings with a ValueError.

This means either:

• The function was removed/renamed since the issue was filed
• The issue describes a function that needs to be added
• The issue references a different branch or version

Regardless, we can proceed with reproduction to confirm the current state and determine the appropriate fix path.

---

Proceeding to Step 4: Reproduction

[Serhan-Asad]

Step 4: Reproduction

Status: Could Not Reproduce

Environment

• Python 3.12.7
• macOS Darwin 24.3.0
• pdd installed in editable mode from gltanaka/pdd (branch fix/issue-625)

Steps Taken

1. Read pdd/xml_tagger.py — confirmed it only exports xml_tagger() and main(). No wrap_xml function exists.
2. Searched entire codebase for wrap_xml — zero results across all files.
3. Attempted the exact reproduction from the issue:

   from pdd.xml_tagger import wrap_xml
   result = wrap_xml("test_tag", "")

4. Checked for prompts/xml_tagger_python.prompt — file does not exist.
5. Reviewed existing tests in tests/test_xml_tagger.py — all tests use xml_tagger(), none reference wrap_xml.

Observed Behavior

ImportError: cannot import name 'wrap_xml' from 'pdd.xml_tagger'
(/Users/serhanasad/Desktop/SF/pdd-gltanaka/pdd/xml_tagger.py)

The reported function wrap_xml does not exist anywhere in the codebase. The import itself fails before any duplicate-tag behavior can be observed.

Affected Files

• pdd/xml_tagger.py — only contains xml_tagger() (LLM-based prompt enhancer) and main()
• tests/test_xml_tagger.py — existing tests cover xml_tagger(), no wrap_xml tests

Notes

• The issue describes a wrap_xml(tag_name, content) function that wraps content in XML tags — this is a different function signature and purpose than the existing xml_tagger(raw_prompt, strength, temperature) which is an LLM-based prompt enhancer.
• The existing xml_tagger() already validates and rejects empty strings with ValueError("raw_prompt must be a non-empty string") (line 43).
• The prompt file prompts/xml_tagger_python.prompt referenced in the Dev Unit section also does not exist.
• This appears to be a bug report for a function that needs to be created, not a bug in existing code. The wrap_xml function would be a simple XML tag wrapper utility, distinct from the LLM-based xml_tagger.

---

Proceeding to Step 5: Root Cause Analysis

[Serhan-Asad]

Step 5: Root Cause Analysis

Root Cause Identified: Yes

Summary

The reported wrap_xml function does not exist in the codebase. The pdd/xml_tagger.py module contains only xml_tagger() (an LLM-based prompt enhancer that uses two LLM calls to add XML tags to prompts) and main(). The issue describes a missing utility function — wrap_xml(tag, content) — that should perform simple XML wrapping (e.g., <tag>content</tag>). The "bug" is that this function needs to be created, and the issue provides the specification: it should handle empty strings correctly, producing <test_tag></test_tag> rather than <test_tag></test_tag></test_tag>.

Technical Details

• Location: pdd/xml_tagger.py — the function wrap_xml is absent from this module
• Problematic Code:

# This import fails with ImportError:
from pdd.xml_tagger import wrap_xml
# wrap_xml does not exist anywhere in the codebase

• Why it fails: The function referenced in the issue (wrap_xml) has never been implemented. The existing xml_tagger() function at line 20 serves a completely different purpose — it's an LLM-based prompt enhancer, not a simple XML string wrapper. There is no simple XML wrapping utility anywhere in the codebase.

External Research

• Search terms: "xml_tagger wrap_xml", "duplicate closing tags XML python", "xml tag wrapping empty string"
• Sources checked: GitHub issues (Serhan-Asad/pdd, gltanaka/pdd), codebase grep
• Relevant findings: No existing utility in the codebase performs simple XML tag wrapping. The pdd/preprocess.py module has process_xml_tags() and related functions, but these process <include>, <shell>, <web>, and <pdd-*> tags in prompt files — they don't create XML tags from scratch.

Repository History

• Relevant commits: 1c4f3007 ("feat: update linting checklist and enhance bug_to_unit_test and xml_tagger modules") was the last change to xml_tagger.py — it enhanced the existing LLM-based function, not adding wrap_xml
• Related PRs: No PRs found referencing wrap_xml or a simple XML wrapping utility
• Similar past issues: No similar issues found (confirmed in Step 1 dedup search)

Experiments Performed

1. Import test: from pdd.xml_tagger import wrap_xml fails with ImportError — the function does not exist
2. Codebase search: Grepped for wrap_xml, xml_wrap, wrap_tag across the entire codebase — zero matches
3. Existing XML patterns: Searched for f-string XML tag construction patterns (f"<{...") — none found in pdd/
4. Test file review: tests/test_xml_tagger.py exists with 10 tests, all for the existing xml_tagger() LLM function — none reference wrap_xml

Fix Scope

• Type: Localized
• The fix is adding a single new function wrap_xml(tag, content) to pdd/xml_tagger.py and adding a corresponding test

Fix Location

• File(s) to modify: pdd/xml_tagger.py
• Why this location: The issue specifies from pdd.xml_tagger import wrap_xml — the function belongs in this module alongside the existing XML tagging functionality
• Existing pattern: The existing xml_tagger() function validates inputs at the top (lines 42-46) before processing. The new wrap_xml should follow the same validation-first pattern.
• Fix approach: Add a wrap_xml(tag: str, content: str) -> str function that:
  1. Validates the tag parameter (non-empty string)
  2. Returns f"<{tag}>{content}</{tag}>" — a single opening tag, the content, and a single closing tag
  3. Handles empty string content correctly by producing <tag></tag> (not duplicating the closing tag)

The bug described in the issue (duplicate closing tags) specifies the behavior the implementation must avoid. The fix is straightforward string formatting with proper handling of the empty-content edge case.

---

Proceeding to Step 5.5: Prompt Classification

[Serhan-Asad]

Step 5.5: Prompt Classification

Classification: Code Bug

DEFECT_TYPE: code

Analysis

The wrap_xml function referenced in the issue does not exist in the codebase, and the prompt file prompts/xml_tagger_python.prompt also does not exist. Since there is no prompt specification to compare against, this is classified as a code bug by default — the code module (pdd/xml_tagger.py) is missing the wrap_xml function entirely.

Evidence

• Prompt specifies: No prompt file exists (prompts/xml_tagger_python.prompt not found). Cannot be a prompt defect if there is no prompt.
• Code implements: pdd/xml_tagger.py only contains xml_tagger() (LLM-based prompt enhancer) and main(). No wrap_xml function exists.
• User expects: A wrap_xml(tag, content) function that produces <test_tag></test_tag> for empty content (not <test_tag></test_tag></test_tag>).

Conclusion

There is no prompt to be defective — the function simply doesn't exist yet. This is a code bug (missing implementation). Proceeding with test generation.

---

Proceeding to Step 6: Test Plan

[Serhan-Asad]

Step 6: Test Plan

Existing Test Coverage

• Test file: tests/test_xml_tagger.py
• Current coverage: Tests cover the LLM-based xml_tagger() function — successful tagging, verbose output, empty prompt rejection, invalid types, invalid strength/temperature, boundary values, parameter combinations, and failed template loading.
• Gap: No tests exist for a wrap_xml() function because the function itself doesn't exist yet. The issue requires adding wrap_xml(tag, content) to pdd/xml_tagger.py and testing it.

Symptom Analysis

The issue describes one distinct symptom:

1. Duplicate closing tags on empty content — wrap_xml("test_tag", "") produces <test_tag></test_tag></test_tag> instead of <test_tag></test_tag>

Channel: This manifests solely through the return value of wrap_xml(). The function is a pure string utility — no stdout, stderr, logging, Rich output, or side effects involved.

Proposed Tests

Test 1: Empty content produces correct tags (primary bug reproduction)

• Input: wrap_xml("test_tag", "")
• Expected: "<test_tag></test_tag>"
• Actual (before fix): "<test_tag></test_tag></test_tag>" (duplicate closing tag) or ImportError (function missing)

Test 2: Non-empty content wrapping

• Input: wrap_xml("data", "hello world")
• Expected: "<data>hello world</data>"

Test 3: Content with newlines

• Input: wrap_xml("code", "line1\nline2")
• Expected: "<code>line1\nline2</code>"

Test 4: Tag name with special characters (underscore, hyphen)

• Input: wrap_xml("my_tag", "content") and wrap_xml("my-tag", "content")
• Expected: "<my_tag>content</my_tag>" and "<my-tag>content</my-tag>"

Test 5: Whitespace-only content

• Input: wrap_xml("tag", " ")
• Expected: "<tag> </tag>" (whitespace preserved, no duplicate tags)

Test 6: Content containing XML-like characters

• Input: wrap_xml("outer", "<inner>text</inner>")
• Expected: "<outer><inner>text</inner></outer>"

Test Location

• File: tests/test_xml_tagger.py (append to existing file)
• Framework: pytest
• Import: from pdd.xml_tagger import wrap_xml

Notes

• No mocking needed — wrap_xml is a pure string utility function with no external dependencies
• Tests should be independent of the existing xml_tagger() tests and mock_deps fixture
• The primary test (Test 1) directly reproduces the exact scenario from the issue

---

Proceeding to Step 7: Generate Test

[Serhan-Asad]

Step 7: Generated Test

Test File

tests/test_xml_tagger.py (appended)

Test Code

class TestWrapXml:
    """Tests for the wrap_xml utility function.

    Issue #196: wrap_xml produces duplicate closing tags when given empty content.
    """

    def test_empty_content_no_duplicate_closing_tag(self):
        """Primary bug: empty content must produce <tag></tag>, not <tag></tag></tag>."""
        from pdd.xml_tagger import wrap_xml
        result = wrap_xml("test_tag", "")
        assert result == "<test_tag></test_tag>", f"Got: {result}"

    def test_non_empty_content_wrapping(self):
        """Non-empty content should be wrapped correctly."""
        from pdd.xml_tagger import wrap_xml
        result = wrap_xml("section", "hello world")
        assert result == "<section>hello world</section>"

    def test_content_with_newlines(self):
        """Content containing newlines should be preserved inside tags."""
        from pdd.xml_tagger import wrap_xml
        result = wrap_xml("block", "line1\nline2\nline3")
        assert result == "<block>line1\nline2\nline3</block>"

    def test_tag_with_special_characters(self):
        """Tag names with underscores and hyphens should work."""
        from pdd.xml_tagger import wrap_xml
        assert wrap_xml("my_tag", "content") == "<my_tag>content</my_tag>"
        assert wrap_xml("my-tag", "content") == "<my-tag>content</my-tag>"

    def test_whitespace_only_content(self):
        """Whitespace-only content should be wrapped, not treated as empty."""
        from pdd.xml_tagger import wrap_xml
        result = wrap_xml("tag", "   ")
        assert result == "<tag>   </tag>"

    def test_content_with_xml_characters(self):
        """Content containing XML-like characters should be wrapped as-is."""
        from pdd.xml_tagger import wrap_xml
        result = wrap_xml("outer", "<inner>value</inner>")
        assert result == "<outer><inner>value</inner></outer>"

What This Test Verifies

6 tests for the missing wrap_xml() function:

1. Primary bug — empty content must produce <tag></tag>, not <tag></tag></tag>
2. Non-empty content wrapping
3. Content with newlines preserved
4. Tag names with underscores/hyphens
5. Whitespace-only content (not treated as empty)
6. Content containing XML-like characters

All 6 tests currently fail with ImportError since wrap_xml doesn't exist in pdd/xml_tagger.py yet.

Running the Test

pytest tests/test_xml_tagger.py::TestWrapXml -v

---

Proceeding to Step 8: Verification

[Serhan-Asad]

Step 8: Verification Complete

Test Execution

tests/test_xml_tagger.py::TestWrapXml::test_empty_content_no_duplicate_closing_tag FAILED
tests/test_xml_tagger.py::TestWrapXml::test_non_empty_content_wrapping FAILED
tests/test_xml_tagger.py::TestWrapXml::test_content_with_newlines FAILED
tests/test_xml_tagger.py::TestWrapXml::test_tag_with_special_characters FAILED
tests/test_xml_tagger.py::TestWrapXml::test_whitespace_only_content FAILED
tests/test_xml_tagger.py::TestWrapXml::test_content_with_xml_characters FAILED

All 6 wrap_xml tests fail with:
ImportError: cannot import name 'wrap_xml' from 'pdd.xml_tagger'

Existing 11 tests: all passed (no regressions).

Verification Status

PASS: Test correctly detects the bug

All 6 tests fail because wrap_xml does not exist in pdd/xml_tagger.py. Once the function is implemented with correct empty-content handling, these tests will validate the fix. The failure mode (ImportError) is the expected first-order failure for a missing function — once added, the primary test (test_empty_content_no_duplicate_closing_tag) will verify the duplicate closing tag bug is resolved.

Summary

Step	Result
Duplicate Check	✅ No duplicates found
Documentation	✅ wrap_xml not in codebase; needs creation
Triage	✅ Proceed — enough info to reproduce
Reproduction	✅ Confirmed wrap_xml missing (ImportError)
Root Cause	✅ Function does not exist; must be added
Prompt Classification	✅ Code bug (DEFECT_TYPE: code)
Test Plan	✅ 6 tests covering empty, non-empty, newlines, special chars, whitespace, XML content
Test Generation	✅ Tests written to tests/test_xml_tagger.py
Verification	✅ All 6 tests fail as expected; 11 existing tests still pass

Bug Details

• Location: pdd/xml_tagger.py — missing wrap_xml function
• Root Cause: The wrap_xml(tag, content) function referenced in the issue does not exist in the module. It needs to be added with correct handling of empty content to produce <tag></tag> (not <tag></tag></tag>).
• Test File: tests/test_xml_tagger.py (6 new tests in TestWrapXml class)

Next Steps

1. Add wrap_xml(tag: str, content: str) -> str to pdd/xml_tagger.py
2. Ensure empty content produces <tag></tag> (no duplicate closing tags)
3. Run pytest tests/test_xml_tagger.py to confirm all 17 tests pass
4. Run full test suite to check for regressions
5. Submit PR with fix and test

---

Proceeding to Step 9: E2E Tests

[Serhan-Asad]

Step 9: E2E Test

Environment Discovery

• Repository language: Python 3.12
• Test framework: pytest 8.3.5
• Existing E2E tests found: Yes — 50+ files in tests/test_e2e_issue_*.py pattern
• Test configuration: pytest.ini at repo root
• Fixtures/helpers used: None needed (wrap_xml is a pure function, no mocking required)
• Environment variables required: None
• Auth/credentials: N/A — no external services involved

E2E Test File

tests/test_e2e_issue_196_xml_tagger_empty_content.py

Test Type

Integration — exercises wrap_xml through composed, realistic usage patterns (nested wrapping, multi-tag document building, XML parse validation)

What This Test Verifies

These tests go beyond the unit tests by verifying that wrap_xml works correctly in composed scenarios that a real consumer would use:

1. Import + empty wrap — full import path from pdd.xml_tagger with empty content
2. Nested XML composition — wrapping an empty inner tag inside an outer tag (duplicate closing tags cascade into malformed nesting)
3. Multi-tag document — concatenating several wrapped tags including empty ones (duplicate closing tags accumulate)
4. XML parse round-trip — feeding wrap_xml output to xml.etree.ElementTree to verify it produces well-formed XML (duplicate closing tag = ParseError)

Test Code

"""
E2E Test for Issue #196: xml_tagger wraps empty string in duplicate tags
"""

import pytest


class TestE2EIssue196EmptyContentXmlWrapping:
    """E2E tests for Issue #196: wrap_xml duplicate closing tags on empty content."""

    def test_e2e_import_and_empty_wrap(self):
        """Full import-path test: pdd.xml_tagger.wrap_xml handles empty content."""
        from pdd.xml_tagger import wrap_xml
        result = wrap_xml("test_tag", "")
        assert result == "<test_tag></test_tag>", f"Got: {result}"
        assert result.count("</test_tag>") == 1, f"Duplicate closing tags detected: {result}"

    def test_e2e_nested_xml_with_empty_inner(self):
        """Compose wrap_xml calls: outer tag wrapping an empty inner tag."""
        from pdd.xml_tagger import wrap_xml
        inner = wrap_xml("inner", "")
        outer = wrap_xml("outer", inner)
        assert outer == "<outer><inner></inner></outer>", f"Got: {outer}"

    def test_e2e_multiple_empty_tags_concatenated(self):
        """Build a document from multiple empty-content tags."""
        from pdd.xml_tagger import wrap_xml
        parts = [
            wrap_xml("header", ""),
            wrap_xml("body", "some content"),
            wrap_xml("footer", ""),
        ]
        document = "\n".join(parts)
        assert "<header></header>" in document
        assert "<footer></footer>" in document
        assert document.count("</header>") == 1
        assert document.count("</footer>") == 1

    def test_e2e_wrap_xml_round_trip_parsing(self):
        """Verify wrap_xml output for empty content is valid XML."""
        from pdd.xml_tagger import wrap_xml
        import xml.etree.ElementTree as ET
        result = wrap_xml("valid_tag", "")
        try:
            elem = ET.fromstring(result)
        except ET.ParseError as exc:
            pytest.fail(f"wrap_xml produced invalid XML: {result!r} — {exc}")
        assert elem.tag == "valid_tag"
        assert elem.text is None or elem.text == ""

Test Execution Result

FAILED test_e2e_import_and_empty_wrap - ImportError: cannot import name 'wrap_xml' from 'pdd.xml_tagger'
FAILED test_e2e_nested_xml_with_empty_inner - ImportError: cannot import name 'wrap_xml' from 'pdd.xml_tagger'
FAILED test_e2e_multiple_empty_tags_concatenated - ImportError: cannot import name 'wrap_xml' from 'pdd.xml_tagger'
FAILED test_e2e_wrap_xml_round_trip_parsing - ImportError: cannot import name 'wrap_xml' from 'pdd.xml_tagger'
4 failed in 1.78s

All 4 E2E tests fail with ImportError — wrap_xml does not exist in pdd/xml_tagger.py. Existing 11 unit tests pass with no regressions.

E2E Test Status

PASS: E2E test correctly detects the bug (missing function). All tests will pass once wrap_xml is implemented with correct empty-content handling.

---

Proceeding to Step 10: Create Draft PR

[Serhan-Asad]

Step 10: Draft PR Created

Pull Request

PR #713: Add failing tests for #196

Branch

fix/issue-196

What's Included

• Failing unit test at tests/test_xml_tagger.py (6 new tests)
• Failing E2E test at tests/test_e2e_issue_196_xml_tagger_empty_content.py (4 new tests)
• Commits: 1

Next Steps for Maintainers

1. Review the failing tests to understand the expected behavior
2. Implement the fix — add wrap_xml(tag, content) to pdd/xml_tagger.py
3. Verify both unit and E2E tests pass with your fix
4. Run full test suite to check for regressions
5. Mark the PR as ready for review

PDD Fix Command

To auto-fix this bug using PDD:

pdd fix https://github.com/Serhan-Asad/pdd/issues/196

Tip: Use --protect-tests if the tests are known to be correct, or --max-cycles N to limit fix attempts.

---

Investigation complete. A draft PR with failing tests has been created and linked to this issue.

[Serhan-Asad]

Step 1: Unit Test Execution (Cycle 1)

Status: All Tests Pass

Unit Tests Identified

• tests/test_xml_tagger.py::TestWrapXml::test_empty_content_no_duplicate_closing_tag
• tests/test_xml_tagger.py::TestWrapXml::test_non_empty_content_wrapping
• tests/test_xml_tagger.py::TestWrapXml::test_content_with_newlines
• tests/test_xml_tagger.py::TestWrapXml::test_tag_with_special_characters
• tests/test_xml_tagger.py::TestWrapXml::test_whitespace_only_content
• tests/test_xml_tagger.py::TestWrapXml::test_content_with_xml_characters

Initial Test Results

• Passed: 0
• Failed: 6 (all with ImportError: cannot import name 'wrap_xml' from 'pdd.xml_tagger')

Fix Applied

No prompt file (prompts/xml_tagger_python.prompt) exists, so pdd fix --manual was not applicable. Applied direct code fix: added wrap_xml(tag: str, content: str) -> str function to pdd/xml_tagger.py that returns f"<{tag}>{content}</{tag}>".

pdd fix Runs

Dev Unit	Result
xml_tagger	Fixed (direct — no prompt file available for pdd fix --manual)

Final Test Results

• Passed: 17 (11 existing + 6 new)
• Failed: 0

---

Proceeding to Step 2: E2E Test Check

[Serhan-Asad]

Step 2: E2E Test Check (Cycle 1)

Status: ALL_TESTS_PASS

E2E Tests Run

• test_e2e_issue_196_xml_tagger_empty_content.py::TestE2EIssue196EmptyContentXmlWrapping::test_e2e_import_and_empty_wrap ✓
• test_e2e_issue_196_xml_tagger_empty_content.py::TestE2EIssue196EmptyContentXmlWrapping::test_e2e_nested_xml_with_empty_inner ✓
• test_e2e_issue_196_xml_tagger_empty_content.py::TestE2EIssue196EmptyContentXmlWrapping::test_e2e_multiple_empty_tags_concatenated ✓
• test_e2e_issue_196_xml_tagger_empty_content.py::TestE2EIssue196EmptyContentXmlWrapping::test_e2e_wrap_xml_round_trip_parsing ✓

Summary

All 4 e2e tests pass. Bug fix complete!

---

Workflow complete - all tests passing