fix: preserve pom.xml formatting in config writer and align write/remove priority

Replace xml.etree.ElementTree with text-based regex manipulation in
_write_maven_properties() and _remove_java_build_config(). ElementTree
destroys XML comments, mangles namespace declarations (ns0: prefixes),
and reformats whitespace. The new approach reads/writes pom.xml as plain
text, only touching codeflash.* property lines.

Also extracts duplicated key_map to shared _MAVEN_KEY_MAP constant and
aligns remove priority to check pom.xml first (matching write order).

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: mohamedashrraf222

codeflash/setup/config_writer.py

@@ -124,47 +124,87 @@ def _write_java_build_config(project_root: Path, config: CodeflashConfig) -> tup
     return _write_gradle_properties(gradle_props_path, non_default)
 
 
+_MAVEN_KEY_MAP: dict[str, str] = {
+    "module-root": "moduleRoot",
+    "tests-root": "testsRoot",
+    "git-remote": "gitRemote",
+    "disable-telemetry": "disableTelemetry",
+    "ignore-paths": "ignorePaths",
+    "formatter-cmds": "formatterCmds",
+}
+
+
 def _write_maven_properties(pom_path: Path, config: dict[str, Any]) -> tuple[bool, str]:
-    """Add codeflash.* properties to pom.xml <properties> section."""
-    import xml.etree.ElementTree as ET
+    """Add codeflash.* properties to pom.xml <properties> section.
+
+    Uses text-based manipulation to preserve comments, formatting, and namespace declarations.
+    """
+    import re
 
     try:
-        tree = ET.parse(str(pom_path))
-        root = tree.getroot()
-        ns = {"m": "http://maven.apache.org/POM/4.0.0"}
-
-        # Find or create <properties>
-        properties = root.find("m:properties", ns) or root.find("properties")
-        if properties is None:
-            properties = ET.SubElement(root, "properties")
-
-        # Convert kebab-case keys to camelCase for Maven convention
-        key_map = {
-            "module-root": "moduleRoot",
-            "tests-root": "testsRoot",
-            "git-remote": "gitRemote",
-            "disable-telemetry": "disableTelemetry",
-            "ignore-paths": "ignorePaths",
-            "formatter-cmds": "formatterCmds",
-        }
+        content = pom_path.read_text(encoding="utf-8")
+
+        # Remove existing codeflash.* property lines (with surrounding whitespace)
+        content = re.sub(r"\n[ \t]*<codeflash\.[^>]*>[^<]*</codeflash\.[^>]*>", "", content)
+
+        # Detect child indentation from existing properties or fall back to </properties> indent + 4 spaces
+        props_close = re.search(r"([ \t]*)</properties>", content)
+        if props_close:
+            parent_indent = props_close.group(1)
+            # Try to detect child indent from an existing property element
+            child_match = re.search(
+                r"\n([ \t]+)<[a-zA-Z]",
+                content[content.find("<properties>") : props_close.start()] if "<properties>" in content else "",
+            )
+            child_indent = child_match.group(1) if child_match else parent_indent + "    "
+        else:
+            parent_indent = ""
+            child_indent = "    "
 
+        # Build new property lines with detected indentation
+        new_lines = []
         for key, value in config.items():
-            maven_key = f"codeflash.{key_map.get(key, key)}"
+            maven_key = f"codeflash.{_MAVEN_KEY_MAP.get(key, key)}"
             if isinstance(value, list):
                 value = ",".join(str(v) for v in value)
             elif isinstance(value, bool):
                 value = str(value).lower()
             else:
                 value = str(value)
-
-            existing = properties.find(maven_key)
-            if existing is None:
-                elem = ET.SubElement(properties, maven_key)
-                elem.text = value
-            else:
-                existing.text = value
-
-        tree.write(str(pom_path), xml_declaration=True, encoding="UTF-8")
+            new_lines.append(f"{child_indent}<{maven_key}>{value}</{maven_key}>")
+
+        properties_block = "\n".join(new_lines)
+
+        # Insert before </properties>
+        if props_close:
+            content = (
+                content[: props_close.start()]
+                + properties_block
+                + "\n"
+                + parent_indent
+                + "</properties>"
+                + content[props_close.end() :]
+            )
+        else:
+            # No <properties> section — create one before </project>
+            project_close = re.search(r"([ \t]*)</project>", content)
+            if project_close:
+                indent = project_close.group(1)
+                inner = "  " + indent
+                props_section = (
+                    f"{inner}<properties>\n"
+                    + "\n".join(f"  {line}" for line in new_lines)
+                    + f"\n{inner}</properties>\n"
+                )
+                content = (
+                    content[: project_close.start()]
+                    + props_section
+                    + indent
+                    + "</project>"
+                    + content[project_close.end() :]
+                )
+
+        pom_path.write_text(content, encoding="utf-8")
         return True, f"Config saved to {pom_path} <properties>"
 
     except Exception as e:
@@ -173,15 +213,6 @@ def _write_maven_properties(pom_path: Path, config: dict[str, Any]) -> tuple[boo
 
 def _write_gradle_properties(props_path: Path, config: dict[str, Any]) -> tuple[bool, str]:
     """Add codeflash.* entries to gradle.properties."""
-    key_map = {
-        "module-root": "moduleRoot",
-        "tests-root": "testsRoot",
-        "git-remote": "gitRemote",
-        "disable-telemetry": "disableTelemetry",
-        "ignore-paths": "ignorePaths",
-        "formatter-cmds": "formatterCmds",
-    }
-
     try:
         lines = []
         if props_path.exists():
@@ -195,7 +226,7 @@ def _write_gradle_properties(props_path: Path, config: dict[str, Any]) -> tuple[
             lines.append("")
         lines.append("# Codeflash configuration — https://docs.codeflash.ai")
         for key, value in config.items():
-            gradle_key = f"codeflash.{key_map.get(key, key)}"
+            gradle_key = f"codeflash.{_MAVEN_KEY_MAP.get(key, key)}"
             if isinstance(value, list):
                 value = ",".join(str(v) for v in value)
             elif isinstance(value, bool):
@@ -306,8 +337,25 @@ def _remove_from_pyproject(project_root: Path) -> tuple[bool, str]:
 
 
 def _remove_java_build_config(project_root: Path) -> tuple[bool, str]:
-    """Remove codeflash.* properties from pom.xml or gradle.properties."""
-    # Try gradle.properties first (simpler)
+    """Remove codeflash.* properties from pom.xml or gradle.properties.
+
+    Priority matches _write_java_build_config: pom.xml first, then gradle.properties.
+    """
+    # Try pom.xml first (matches write priority) — text-based removal preserves formatting
+    pom_path = project_root / "pom.xml"
+    if pom_path.exists():
+        try:
+            import re
+
+            content = pom_path.read_text(encoding="utf-8")
+            updated = re.sub(r"\n[ \t]*<codeflash\.[^>]*>[^<]*</codeflash\.[^>]*>", "", content)
+            if updated != content:
+                pom_path.write_text(updated, encoding="utf-8")
+            return True, "Removed codeflash properties from pom.xml"
+        except Exception as e:
+            return False, f"Failed to remove config from pom.xml: {e}"
+
+    # Try gradle.properties
     gradle_props = project_root / "gradle.properties"
     if gradle_props.exists():
         try:
@@ -316,33 +364,13 @@ def _remove_java_build_config(project_root: Path) -> tuple[bool, str]:
                 line
                 for line in lines
                 if not line.strip().startswith("codeflash.")
-                and line.strip() != "# Codeflash configuration — https://docs.codeflash.ai"
+                and line.strip() != "# Codeflash configuration \u2014 https://docs.codeflash.ai"
             ]
             gradle_props.write_text("\n".join(filtered) + "\n", encoding="utf-8")
             return True, "Removed codeflash properties from gradle.properties"
         except Exception as e:
             return False, f"Failed to remove config from gradle.properties: {e}"
 
-    # Try pom.xml
-    pom_path = project_root / "pom.xml"
-    if pom_path.exists():
-        try:
-            import xml.etree.ElementTree as ET
-
-            tree = ET.parse(str(pom_path))
-            root = tree.getroot()
-            ns = {"m": "http://maven.apache.org/POM/4.0.0"}
-            for properties in [root.find("m:properties", ns), root.find("properties")]:
-                if properties is None:
-                    continue
-                to_remove = [child for child in properties if child.tag.split("}")[-1].startswith("codeflash.")]
-                for elem in to_remove:
-                    properties.remove(elem)
-            tree.write(str(pom_path), xml_declaration=True, encoding="UTF-8")
-            return True, "Removed codeflash properties from pom.xml"
-        except Exception as e:
-            return False, f"Failed to remove config from pom.xml: {e}"
-
     return True, "No Java build config found"
 
 

codeflash/setup/detector.py

@@ -900,7 +900,8 @@ def has_existing_config(project_root: Path) -> tuple[bool, str | None]:
         except Exception:
             pass
 
-    # Check Java build files — Java projects store config in pom.xml properties or gradle.properties
+    # Check Java build files — for zero-config Java, any build file means "configured"
+    # because Java config is auto-detected from build files without explicit codeflash.* properties
     for build_file in ("pom.xml", "build.gradle", "build.gradle.kts"):
         if (project_root / build_file).exists():
             return True, build_file

tests/test_setup/test_config_writer.py

@@ -0,0 +1,148 @@
+"""Tests for config_writer module — Java pom.xml formatting preservation."""
+
+from pathlib import Path
+
+
+class TestWriteMavenProperties:
+    """Tests for _write_maven_properties — text-based pom.xml editing."""
+
+    def test_preserves_comments(self, tmp_path: Path) -> None:
+        pom = tmp_path / "pom.xml"
+        pom.write_text(
+            '<?xml version="1.0" encoding="UTF-8"?>\n'
+            "<project>\n"
+            "  <!-- Important comment -->\n"
+            "  <properties>\n"
+            "    <maven.compiler.source>17</maven.compiler.source>\n"
+            "  </properties>\n"
+            "</project>\n",
+            encoding="utf-8",
+        )
+
+        from codeflash.setup.config_writer import _write_maven_properties
+
+        ok, _ = _write_maven_properties(pom, {"module-root": "src/main/java"})
+        result = pom.read_text(encoding="utf-8")
+
+        assert ok
+        assert "<!-- Important comment -->" in result
+        assert "<codeflash.moduleRoot>src/main/java</codeflash.moduleRoot>" in result
+
+    def test_preserves_namespace(self, tmp_path: Path) -> None:
+        pom = tmp_path / "pom.xml"
+        pom.write_text(
+            '<?xml version="1.0" encoding="UTF-8"?>\n'
+            '<project xmlns="http://maven.apache.org/POM/4.0.0">\n'
+            "  <properties>\n"
+            "    <maven.compiler.source>17</maven.compiler.source>\n"
+            "  </properties>\n"
+            "</project>\n",
+            encoding="utf-8",
+        )
+
+        from codeflash.setup.config_writer import _write_maven_properties
+
+        ok, _ = _write_maven_properties(pom, {"module-root": "src/main/java"})
+        result = pom.read_text(encoding="utf-8")
+
+        assert ok
+        assert 'xmlns="http://maven.apache.org/POM/4.0.0"' in result
+        # Must NOT have ns0: prefix (ElementTree bug)
+        assert "ns0:" not in result
+
+    def test_updates_existing_codeflash_properties(self, tmp_path: Path) -> None:
+        pom = tmp_path / "pom.xml"
+        pom.write_text(
+            "<project>\n"
+            "  <properties>\n"
+            "    <codeflash.moduleRoot>old/path</codeflash.moduleRoot>\n"
+            "  </properties>\n"
+            "</project>\n",
+            encoding="utf-8",
+        )
+
+        from codeflash.setup.config_writer import _write_maven_properties
+
+        ok, _ = _write_maven_properties(pom, {"module-root": "new/path"})
+        result = pom.read_text(encoding="utf-8")
+
+        assert ok
+        assert "old/path" not in result
+        assert "<codeflash.moduleRoot>new/path</codeflash.moduleRoot>" in result
+
+    def test_creates_properties_section(self, tmp_path: Path) -> None:
+        pom = tmp_path / "pom.xml"
+        pom.write_text(
+            "<project>\n" "  <modelVersion>4.0.0</modelVersion>\n" "</project>\n",
+            encoding="utf-8",
+        )
+
+        from codeflash.setup.config_writer import _write_maven_properties
+
+        ok, _ = _write_maven_properties(pom, {"module-root": "src/main/java"})
+        result = pom.read_text(encoding="utf-8")
+
+        assert ok
+        assert "<properties>" in result
+        assert "<codeflash.moduleRoot>src/main/java</codeflash.moduleRoot>" in result
+
+    def test_converts_kebab_to_camelcase(self, tmp_path: Path) -> None:
+        pom = tmp_path / "pom.xml"
+        pom.write_text(
+            "<project>\n  <properties>\n  </properties>\n</project>\n",
+            encoding="utf-8",
+        )
+
+        from codeflash.setup.config_writer import _write_maven_properties
+
+        ok, _ = _write_maven_properties(pom, {"ignore-paths": ["target", "build"]})
+        result = pom.read_text(encoding="utf-8")
+
+        assert ok
+        assert "<codeflash.ignorePaths>target,build</codeflash.ignorePaths>" in result
+
+
+class TestRemoveJavaBuildConfig:
+    """Tests for _remove_java_build_config — preserves formatting during removal."""
+
+    def test_removes_codeflash_from_pom_preserving_others(self, tmp_path: Path) -> None:
+        pom = tmp_path / "pom.xml"
+        pom.write_text(
+            "<project>\n"
+            "  <!-- Keep me -->\n"
+            "  <properties>\n"
+            "    <maven.compiler.source>17</maven.compiler.source>\n"
+            "    <codeflash.moduleRoot>src/main/java</codeflash.moduleRoot>\n"
+            "  </properties>\n"
+            "</project>\n",
+            encoding="utf-8",
+        )
+
+        from codeflash.setup.config_writer import _remove_java_build_config
+
+        ok, _ = _remove_java_build_config(tmp_path)
+        result = pom.read_text(encoding="utf-8")
+
+        assert ok
+        assert "<!-- Keep me -->" in result
+        assert "<maven.compiler.source>17</maven.compiler.source>" in result
+        assert "codeflash.moduleRoot" not in result
+
+    def test_removes_codeflash_from_gradle_properties(self, tmp_path: Path) -> None:
+        gradle = tmp_path / "gradle.properties"
+        gradle.write_text(
+            "org.gradle.jvmargs=-Xmx2g\n"
+            "# Codeflash configuration \u2014 https://docs.codeflash.ai\n"
+            "codeflash.moduleRoot=src/main/java\n"
+            "codeflash.testsRoot=src/test/java\n",
+            encoding="utf-8",
+        )
+
+        from codeflash.setup.config_writer import _remove_java_build_config
+
+        ok, _ = _remove_java_build_config(tmp_path)
+        result = gradle.read_text(encoding="utf-8")
+
+        assert ok
+        assert "org.gradle.jvmargs=-Xmx2g" in result
+        assert "codeflash." not in result

tests/test_setup/test_detector.py

@@ -558,6 +558,22 @@ def test_returns_false_when_no_config(self, tmp_path):
         assert has_config is False
         assert config_type is None
 
+    def test_java_pom_xml_is_zero_config(self, tmp_path):
+        """Java projects with pom.xml are zero-config — build file presence means configured."""
+        (tmp_path / "pom.xml").write_text("<project><modelVersion>4.0.0</modelVersion></project>")
+
+        has_config, config_type = has_existing_config(tmp_path)
+        assert has_config is True
+        assert config_type == "pom.xml"
+
+    def test_java_build_gradle_is_zero_config(self, tmp_path):
+        """Java projects with build.gradle are zero-config — build file presence means configured."""
+        (tmp_path / "build.gradle").write_text('plugins { id "java" }')
+
+        has_config, config_type = has_existing_config(tmp_path)
+        assert has_config is True
+        assert config_type == "build.gradle"
+
     def test_returns_false_for_empty_directory(self, tmp_path):
         """Should return False for empty directory."""
         has_config, config_type = has_existing_config(tmp_path)