Merge branch 'integration' into memory_api

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

esphome/__main__.py

@@ -643,6 +643,13 @@ def command_vscode(args: ArgsProtocol) -> int | None:
 
 
 def command_compile(args: ArgsProtocol, config: ConfigType) -> int | None:
+    # Set memory analysis options in config
+    if args.analyze_memory:
+        config.setdefault(CONF_ESPHOME, {})["analyze_memory"] = True
+
+    if args.memory_report:
+        config.setdefault(CONF_ESPHOME, {})["memory_report_file"] = args.memory_report
+
     exit_code = write_cpp(config)
     if exit_code != 0:
         return exit_code
@@ -1055,6 +1062,17 @@ def parse_args(argv):
         help="Only generate source code, do not compile.",
         action="store_true",
     )
+    parser_compile.add_argument(
+        "--analyze-memory",
+        help="Analyze and display memory usage by component after compilation.",
+        action="store_true",
+    )
+    parser_compile.add_argument(
+        "--memory-report",
+        help="Save memory analysis report to a file (supports .json or .txt).",
+        type=str,
+        metavar="FILE",
+    )
 
     parser_upload = subparsers.add_parser(
         "upload",

esphome/components/api/api.proto

@@ -866,7 +866,7 @@ message ListEntitiesServicesResponse {
 
   string name = 1;
   fixed32 key = 2;
-  repeated ListEntitiesServicesArgument args = 3;
+  repeated ListEntitiesServicesArgument args = 3 [(fixed_vector) = true];
 }
 message ExecuteServiceArgument {
   option (ifdef) = "USE_API_SERVICES";

esphome/components/api/api_frame_helper_noise.cpp

@@ -142,6 +142,11 @@ APIError APINoiseFrameHelper::loop() {
  * errno API_ERROR_HANDSHAKE_PACKET_LEN: Packet too big for this phase.
  */
 APIError APINoiseFrameHelper::try_read_frame_() {
+  // Clear buffer when starting a new frame (rx_buf_len_ == 0 means not resuming after WOULD_BLOCK)
+  if (this->rx_buf_len_ == 0) {
+    this->rx_buf_.clear();
+  }
+
   // read header
   if (rx_header_buf_len_ < 3) {
     // no header information yet

esphome/components/api/api_frame_helper_plaintext.cpp

@@ -54,6 +54,11 @@ APIError APIPlaintextFrameHelper::loop() {
  * error API_ERROR_BAD_INDICATOR: Bad indicator byte at start of frame.
  */
 APIError APIPlaintextFrameHelper::try_read_frame_() {
+  // Clear buffer when starting a new frame (rx_buf_len_ == 0 means not resuming after WOULD_BLOCK)
+  if (this->rx_buf_len_ == 0) {
+    this->rx_buf_.clear();
+  }
+
   // read header
   while (!rx_header_parsed_) {
     // Now that we know when the socket is ready, we can read up to 3 bytes

esphome/components/api/api_pb2.h

@@ -1263,7 +1263,7 @@ class ListEntitiesServicesResponse final : public ProtoMessage {
   StringRef name_ref_{};
   void set_name(const StringRef &ref) { this->name_ref_ = ref; }
   uint32_t key{0};
-  std::vector<ListEntitiesServicesArgument> args{};
+  FixedVector<ListEntitiesServicesArgument> args{};
   void encode(ProtoWriteBuffer buffer) const override;
   void calculate_size(ProtoSize &size) const override;
 #ifdef HAS_PROTO_MESSAGE_DUMP

esphome/components/api/user_services.h

@@ -35,9 +35,9 @@ template<typename... Ts> class UserServiceBase : public UserServiceDescriptor {
     msg.set_name(StringRef(this->name_));
     msg.key = this->key_;
     std::array<enums::ServiceArgType, sizeof...(Ts)> arg_types = {to_service_arg_type<Ts>()...};
+    msg.args.init(sizeof...(Ts));
     for (size_t i = 0; i < sizeof...(Ts); i++) {
-      msg.args.emplace_back();
-      auto &arg = msg.args.back();
+      auto &arg = msg.args.emplace_back();
       arg.type = arg_types[i];
       arg.set_name(StringRef(this->arg_names_[i]));
     }

esphome/components/esp32_ble/__init__.py

@@ -108,8 +108,13 @@ class BTLoggers(Enum):
     """ESP32 WiFi provisioning over Bluetooth"""
 
 
-# Set to track which loggers are needed by components
-_required_loggers: set[BTLoggers] = set()
+# Key for storing required loggers in CORE.data
+ESP32_BLE_REQUIRED_LOGGERS_KEY = "esp32_ble_required_loggers"
+
+
+def _get_required_loggers() -> set[BTLoggers]:
+    """Get the set of required Bluetooth loggers from CORE.data."""
+    return CORE.data.setdefault(ESP32_BLE_REQUIRED_LOGGERS_KEY, set())
 
 
 # Dataclass for handler registration counts
@@ -170,12 +175,13 @@ def register_bt_logger(*loggers: BTLoggers) -> None:
     Args:
         *loggers: One or more BTLoggers enum members
     """
+    required_loggers = _get_required_loggers()
     for logger in loggers:
         if not isinstance(logger, BTLoggers):
             raise TypeError(
                 f"Logger must be a BTLoggers enum member, got {type(logger)}"
             )
-        _required_loggers.add(logger)
+        required_loggers.add(logger)
 
 
 CONF_BLE_ID = "ble_id"
@@ -479,8 +485,9 @@ async def to_code(config):
     # Apply logger settings if log disabling is enabled
     if config.get(CONF_DISABLE_BT_LOGS, False):
         # Disable all Bluetooth loggers that are not required
+        required_loggers = _get_required_loggers()
         for logger in BTLoggers:
-            if logger not in _required_loggers:
+            if logger not in required_loggers:
                 add_idf_sdkconfig_option(f"{logger.value}_NONE", True)
 
     # Set BLE connection establishment timeout to match aioesphomeapi/bleak-retry-connector

esphome/components/esp32_ble/ble.cpp

@@ -68,6 +68,10 @@ void ESP32BLE::advertising_set_service_data(const std::vector<uint8_t> &data) {
 }
 
 void ESP32BLE::advertising_set_manufacturer_data(const std::vector<uint8_t> &data) {
+  this->advertising_set_manufacturer_data(std::span<const uint8_t>(data));
+}
+
+void ESP32BLE::advertising_set_manufacturer_data(std::span<const uint8_t> data) {
   this->advertising_init_();
   this->advertising_->set_manufacturer_data(data);
   this->advertising_start();

esphome/components/esp32_ble/ble.h

@@ -118,6 +118,7 @@ class ESP32BLE : public Component {
   void advertising_start();
   void advertising_set_service_data(const std::vector<uint8_t> &data);
   void advertising_set_manufacturer_data(const std::vector<uint8_t> &data);
+  void advertising_set_manufacturer_data(std::span<const uint8_t> data);
   void advertising_set_appearance(uint16_t appearance) { this->appearance_ = appearance; }
   void advertising_set_service_data_and_name(std::span<const uint8_t> data, bool include_name);
   void advertising_add_service_uuid(ESPBTUUID uuid);

esphome/components/esp32_ble/ble_advertising.cpp

@@ -59,6 +59,10 @@ void BLEAdvertising::set_service_data(const std::vector<uint8_t> &data) {
 }
 
 void BLEAdvertising::set_manufacturer_data(const std::vector<uint8_t> &data) {
+  this->set_manufacturer_data(std::span<const uint8_t>(data));
+}
+
+void BLEAdvertising::set_manufacturer_data(std::span<const uint8_t> data) {
   delete[] this->advertising_data_.p_manufacturer_data;
   this->advertising_data_.p_manufacturer_data = nullptr;
   this->advertising_data_.manufacturer_len = data.size();

esphome/components/esp32_ble/ble_advertising.h

@@ -35,6 +35,7 @@ class BLEAdvertising {
   void set_scan_response(bool scan_response) { this->scan_response_ = scan_response; }
   void set_min_preferred_interval(uint16_t interval) { this->advertising_data_.min_interval = interval; }
   void set_manufacturer_data(const std::vector<uint8_t> &data);
+  void set_manufacturer_data(std::span<const uint8_t> data);
   void set_appearance(uint16_t appearance) { this->advertising_data_.appearance = appearance; }
   void set_service_data(const std::vector<uint8_t> &data);
   void set_service_data(std::span<const uint8_t> data);

esphome/components/esp32_ble_beacon/esp32_ble_beacon.cpp

@@ -1,5 +1,6 @@
 #include "esp32_ble_beacon.h"
 #include "esphome/core/log.h"
+#include "esphome/core/helpers.h"
 
 #ifdef USE_ESP32
 

esphome/components/esp32_ble_server/ble_server_automations.cpp

@@ -15,7 +15,10 @@ Trigger<std::vector<uint8_t>, uint16_t> *BLETriggers::create_characteristic_on_w
   Trigger<std::vector<uint8_t>, uint16_t> *on_write_trigger =  // NOLINT(cppcoreguidelines-owning-memory)
       new Trigger<std::vector<uint8_t>, uint16_t>();
   characteristic->on_write([on_write_trigger](std::span<const uint8_t> data, uint16_t id) {
-    // Convert span to vector for trigger
+    // Convert span to vector for trigger - copy is necessary because:
+    // 1. Trigger stores the data for use in automation actions that execute later
+    // 2. The span is only valid during this callback (points to temporary BLE stack data)
+    // 3. User lambdas in automations need persistent data they can access asynchronously
     on_write_trigger->trigger(std::vector<uint8_t>(data.begin(), data.end()), id);
   });
   return on_write_trigger;
@@ -27,7 +30,10 @@ Trigger<std::vector<uint8_t>, uint16_t> *BLETriggers::create_descriptor_on_write
   Trigger<std::vector<uint8_t>, uint16_t> *on_write_trigger =  // NOLINT(cppcoreguidelines-owning-memory)
       new Trigger<std::vector<uint8_t>, uint16_t>();
   descriptor->on_write([on_write_trigger](std::span<const uint8_t> data, uint16_t id) {
-    // Convert span to vector for trigger
+    // Convert span to vector for trigger - copy is necessary because:
+    // 1. Trigger stores the data for use in automation actions that execute later
+    // 2. The span is only valid during this callback (points to temporary BLE stack data)
+    // 3. User lambdas in automations need persistent data they can access asynchronously
     on_write_trigger->trigger(std::vector<uint8_t>(data.begin(), data.end()), id);
   });
   return on_write_trigger;

esphome/components/esp32_ble_tracker/__init__.py

@@ -60,11 +60,21 @@ class RegistrationCounts:
     clients: int = 0
 
 
-# Set to track which features are needed by components
-_required_features: set[BLEFeatures] = set()
+# CORE.data keys for state management
+ESP32_BLE_TRACKER_REQUIRED_FEATURES_KEY = "esp32_ble_tracker_required_features"
+ESP32_BLE_TRACKER_REGISTRATION_COUNTS_KEY = "esp32_ble_tracker_registration_counts"
 
-# Track registration counts for StaticVector sizing
-_registration_counts = RegistrationCounts()
+
+def _get_required_features() -> set[BLEFeatures]:
+    """Get the set of required BLE features from CORE.data."""
+    return CORE.data.setdefault(ESP32_BLE_TRACKER_REQUIRED_FEATURES_KEY, set())
+
+
+def _get_registration_counts() -> RegistrationCounts:
+    """Get the registration counts from CORE.data."""
+    return CORE.data.setdefault(
+        ESP32_BLE_TRACKER_REGISTRATION_COUNTS_KEY, RegistrationCounts()
+    )
 
 
 def register_ble_features(features: set[BLEFeatures]) -> None:
@@ -73,7 +83,7 @@ def register_ble_features(features: set[BLEFeatures]) -> None:
     Args:
         features: Set of BLEFeatures enum members
     """
-    _required_features.update(features)
+    _get_required_features().update(features)
 
 
 esp32_ble_tracker_ns = cg.esphome_ns.namespace("esp32_ble_tracker")
@@ -267,15 +277,17 @@ async def to_code(config):
     ):
         register_ble_features({BLEFeatures.ESP_BT_DEVICE})
 
+    registration_counts = _get_registration_counts()
+
     for conf in config.get(CONF_ON_BLE_ADVERTISE, []):
-        _registration_counts.listeners += 1
+        registration_counts.listeners += 1
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
         if CONF_MAC_ADDRESS in conf:
             addr_list = [it.as_hex for it in conf[CONF_MAC_ADDRESS]]
             cg.add(trigger.set_addresses(addr_list))
         await automation.build_automation(trigger, [(ESPBTDeviceConstRef, "x")], conf)
     for conf in config.get(CONF_ON_BLE_SERVICE_DATA_ADVERTISE, []):
-        _registration_counts.listeners += 1
+        registration_counts.listeners += 1
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
         if len(conf[CONF_SERVICE_UUID]) == len(bt_uuid16_format):
             cg.add(trigger.set_service_uuid16(as_hex(conf[CONF_SERVICE_UUID])))
@@ -288,7 +300,7 @@ async def to_code(config):
             cg.add(trigger.set_address(conf[CONF_MAC_ADDRESS].as_hex))
         await automation.build_automation(trigger, [(adv_data_t_const_ref, "x")], conf)
     for conf in config.get(CONF_ON_BLE_MANUFACTURER_DATA_ADVERTISE, []):
-        _registration_counts.listeners += 1
+        registration_counts.listeners += 1
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
         if len(conf[CONF_MANUFACTURER_ID]) == len(bt_uuid16_format):
             cg.add(trigger.set_manufacturer_uuid16(as_hex(conf[CONF_MANUFACTURER_ID])))
@@ -301,7 +313,7 @@ async def to_code(config):
             cg.add(trigger.set_address(conf[CONF_MAC_ADDRESS].as_hex))
         await automation.build_automation(trigger, [(adv_data_t_const_ref, "x")], conf)
     for conf in config.get(CONF_ON_SCAN_END, []):
-        _registration_counts.listeners += 1
+        registration_counts.listeners += 1
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
         await automation.build_automation(trigger, [], conf)
 
@@ -331,19 +343,21 @@ async def to_code(config):
 @coroutine_with_priority(CoroPriority.FINAL)
 async def _add_ble_features():
     # Add feature-specific defines based on what's needed
-    if BLEFeatures.ESP_BT_DEVICE in _required_features:
+    required_features = _get_required_features()
+    if BLEFeatures.ESP_BT_DEVICE in required_features:
         cg.add_define("USE_ESP32_BLE_DEVICE")
         cg.add_define("USE_ESP32_BLE_UUID")
 
     # Add defines for StaticVector sizing based on registration counts
     # Only define if count > 0 to avoid allocating unnecessary memory
-    if _registration_counts.listeners > 0:
+    registration_counts = _get_registration_counts()
+    if registration_counts.listeners > 0:
         cg.add_define(
-            "ESPHOME_ESP32_BLE_TRACKER_LISTENER_COUNT", _registration_counts.listeners
+            "ESPHOME_ESP32_BLE_TRACKER_LISTENER_COUNT", registration_counts.listeners
         )
-    if _registration_counts.clients > 0:
+    if registration_counts.clients > 0:
         cg.add_define(
-            "ESPHOME_ESP32_BLE_TRACKER_CLIENT_COUNT", _registration_counts.clients
+            "ESPHOME_ESP32_BLE_TRACKER_CLIENT_COUNT", registration_counts.clients
         )
 
 
@@ -395,7 +409,7 @@ async def register_ble_device(
     var: cg.SafeExpType, config: ConfigType
 ) -> cg.SafeExpType:
     register_ble_features({BLEFeatures.ESP_BT_DEVICE})
-    _registration_counts.listeners += 1
+    _get_registration_counts().listeners += 1
     paren = await cg.get_variable(config[CONF_ESP32_BLE_ID])
     cg.add(paren.register_listener(var))
     return var
@@ -403,7 +417,7 @@ async def register_ble_device(
 
 async def register_client(var: cg.SafeExpType, config: ConfigType) -> cg.SafeExpType:
     register_ble_features({BLEFeatures.ESP_BT_DEVICE})
-    _registration_counts.clients += 1
+    _get_registration_counts().clients += 1
     paren = await cg.get_variable(config[CONF_ESP32_BLE_ID])
     cg.add(paren.register_client(var))
     return var
@@ -417,7 +431,7 @@ async def register_raw_ble_device(
     This does NOT register the ESP_BT_DEVICE feature, meaning ESPBTDevice
     will not be compiled in if this is the only registration method used.
     """
-    _registration_counts.listeners += 1
+    _get_registration_counts().listeners += 1
     paren = await cg.get_variable(config[CONF_ESP32_BLE_ID])
     cg.add(paren.register_listener(var))
     return var
@@ -431,7 +445,7 @@ async def register_raw_client(
     This does NOT register the ESP_BT_DEVICE feature, meaning ESPBTDevice
     will not be compiled in if this is the only registration method used.
     """
-    _registration_counts.clients += 1
+    _get_registration_counts().clients += 1
     paren = await cg.get_variable(config[CONF_ESP32_BLE_ID])
     cg.add(paren.register_client(var))
     return var

esphome/components/i2c/i2c_bus_esp_idf.cpp

@@ -107,7 +107,7 @@ void IDFI2CBus::dump_config() {
         if (s.second) {
           ESP_LOGCONFIG(TAG, "Found device at address 0x%02X", s.first);
         } else {
-          ESP_LOGE(TAG, "Unknown error at address 0x%02X", s.first);
+          ESP_LOGCONFIG(TAG, "Unknown error at address 0x%02X", s.first);
         }
       }
     }

esphome/components/i2s_audio/__init__.py

@@ -143,7 +143,18 @@ def validate_mclk_divisible_by_3(config):
     return config
 
 
-_use_legacy_driver = None
+# Key for storing legacy driver setting in CORE.data
+I2S_USE_LEGACY_DRIVER_KEY = "i2s_use_legacy_driver"
+
+
+def _get_use_legacy_driver():
+    """Get the legacy driver setting from CORE.data."""
+    return CORE.data.get(I2S_USE_LEGACY_DRIVER_KEY)
+
+
+def _set_use_legacy_driver(value: bool) -> None:
+    """Set the legacy driver setting in CORE.data."""
+    CORE.data[I2S_USE_LEGACY_DRIVER_KEY] = value
 
 
 def i2s_audio_component_schema(
@@ -209,17 +220,15 @@ async def register_i2s_audio_component(var, config):
 
 
 def validate_use_legacy(value):
-    global _use_legacy_driver  # noqa: PLW0603
     if CONF_USE_LEGACY in value:
-        if (_use_legacy_driver is not None) and (
-            _use_legacy_driver != value[CONF_USE_LEGACY]
-        ):
+        existing_value = _get_use_legacy_driver()
+        if (existing_value is not None) and (existing_value != value[CONF_USE_LEGACY]):
             raise cv.Invalid(
                 f"All i2s_audio components must set {CONF_USE_LEGACY} to the same value."
             )
         if (not value[CONF_USE_LEGACY]) and (CORE.using_arduino):
             raise cv.Invalid("Arduino supports only the legacy i2s driver")
-        _use_legacy_driver = value[CONF_USE_LEGACY]
+        _set_use_legacy_driver(value[CONF_USE_LEGACY])
     return value
 
 
@@ -249,7 +258,8 @@ def _final_validate(_):
 
 
 def use_legacy():
-    return not (CORE.using_esp_idf and not _use_legacy_driver)
+    legacy_driver = _get_use_legacy_driver()
+    return not (CORE.using_esp_idf and not legacy_driver)
 
 
 FINAL_VALIDATE_SCHEMA = _final_validate

esphome/components/mcp23016/mcp23016.cpp

@@ -56,7 +56,7 @@ void MCP23016::pin_mode(uint8_t pin, gpio::Flags flags) {
     this->update_reg_(pin, false, iodir);
   }
 }
-float MCP23016::get_setup_priority() const { return setup_priority::HARDWARE; }
+float MCP23016::get_setup_priority() const { return setup_priority::IO; }
 bool MCP23016::read_reg_(uint8_t reg, uint8_t *value) {
   if (this->is_failed())
     return false;

esphome/core/__init__.py

@@ -705,6 +705,15 @@ class EsphomeCore:
     def relative_piolibdeps_path(self, *path: str | Path) -> Path:
         return self.relative_build_path(".piolibdeps", *path)
 
+    @property
+    def platformio_cache_dir(self) -> str:
+        """Get the PlatformIO cache directory path."""
+        # Check if running in Docker/HA addon with custom cache dir
+        if (cache_dir := os.environ.get("PLATFORMIO_CACHE_DIR")) and cache_dir.strip():
+            return cache_dir
+        # Default PlatformIO cache location
+        return os.path.expanduser("~/.platformio/.cache")
+
     @property
     def firmware_bin(self) -> Path:
         if self.is_libretiny:

esphome/core/helpers.cpp

@@ -414,10 +414,8 @@ int8_t step_to_accuracy_decimals(float step) {
   return str.length() - dot_pos - 1;
 }
 
-// Use C-style string constant to store in ROM instead of RAM (saves 24 bytes)
-static constexpr const char *BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-                                            "abcdefghijklmnopqrstuvwxyz"
-                                            "0123456789+/";
+// Store BASE64 characters as array - automatically placed in flash/ROM on embedded platforms
+static const char BASE64_CHARS[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 
 // Helper function to find the index of a base64 character in the lookup table.
 // Returns the character's position (0-63) if found, or 0 if not found.
@@ -427,8 +425,8 @@ static constexpr const char *BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 // stops processing at the first invalid character due to the is_base64() check in its
 // while loop condition, making this edge case harmless in practice.
 static inline uint8_t base64_find_char(char c) {
-  const char *pos = strchr(BASE64_CHARS, c);
-  return pos ? (pos - BASE64_CHARS) : 0;
+  const void *ptr = memchr(BASE64_CHARS, c, sizeof(BASE64_CHARS));
+  return ptr ? (static_cast<const char *>(ptr) - BASE64_CHARS) : 0;
 }
 
 static inline bool is_base64(char c) { return (isalnum(c) || (c == '+') || (c == '/')); }

esphome/core/helpers.h

@@ -143,6 +143,9 @@ template<typename T, size_t N> class StaticVector {
   size_t size() const { return count_; }
   bool empty() const { return count_ == 0; }
 
+  // Direct access to size counter for efficient in-place construction
+  size_t &count() { return count_; }
+
   T &operator[](size_t i) { return data_[i]; }
   const T &operator[](size_t i) const { return data_[i]; }
 

esphome/core/scheduler.h

@@ -95,10 +95,9 @@ class Scheduler {
     } name_;
     uint32_t interval;
     // Split time to handle millis() rollover. The scheduler combines the 32-bit millis()
-    // with a 16-bit rollover counter to create a 48-bit time space (using 32+16 bits).
-    // This is intentionally limited to 48 bits, not stored as a full 64-bit value.
-    // With 49.7 days per 32-bit rollover, the 16-bit counter supports
-    // 49.7 days × 65536 = ~8900 years. This ensures correct scheduling
+    // with a 16-bit rollover counter to create a 48-bit time space (stored as 64-bit
+    // for compatibility). With 49.7 days per 32-bit rollover, the 16-bit counter
+    // supports 49.7 days × 65536 = ~8900 years. This ensures correct scheduling
     // even when devices run for months. Split into two fields for better memory
     // alignment on 32-bit systems.
     uint32_t next_execution_low_;  // Lower 32 bits of execution time (millis value)

esphome/git.py

@@ -5,7 +5,6 @@ import hashlib
 import logging
 from pathlib import Path
 import re
-import shutil
 import subprocess
 import urllib.parse
 
@@ -18,60 +17,14 @@ _LOGGER = logging.getLogger(__name__)
 NEVER_REFRESH = TimePeriodSeconds(seconds=-1)
 
 
-class GitException(cv.Invalid):
-    """Base exception for git-related errors."""
-
-
-class GitNotInstalledError(GitException):
-    """Exception raised when git is not installed on the system."""
-
-
-class GitCommandError(GitException):
-    """Exception raised when a git command fails."""
-
-
-class GitRepositoryError(GitException):
-    """Exception raised when a git repository is in an invalid state."""
-
-
-def run_git_command(cmd: list[str], git_dir: Path | None = None) -> str:
-    if git_dir is not None:
-        _LOGGER.debug(
-            "Running git command with repository isolation: %s (git_dir=%s)",
-            " ".join(cmd),
-            git_dir,
-        )
-    else:
-        _LOGGER.debug("Running git command: %s", " ".join(cmd))
-
-    # Set up environment for repository isolation if git_dir is provided
-    # Force git to only operate on this specific repository by setting
-    # GIT_DIR and GIT_WORK_TREE. This prevents git from walking up the
-    # directory tree to find parent repositories when the target repo's
-    # .git directory is corrupt. Without this, commands like 'git stash'
-    # could accidentally operate on parent repositories (e.g., the main
-    # ESPHome repo) instead of failing, causing data loss.
-    env: dict[str, str] | None = None
-    cwd: str | None = None
-    if git_dir is not None:
-        env = {
-            **subprocess.os.environ,
-            "GIT_DIR": str(Path(git_dir) / ".git"),
-            "GIT_WORK_TREE": str(git_dir),
-        }
-        cwd = str(git_dir)
-
+def run_git_command(cmd, cwd=None) -> str:
+    _LOGGER.debug("Running git command: %s", " ".join(cmd))
     try:
         ret = subprocess.run(
-            cmd,
-            cwd=cwd,
-            capture_output=True,
-            check=False,
-            close_fds=False,
-            env=env,
+            cmd, cwd=cwd, capture_output=True, check=False, close_fds=False
         )
     except FileNotFoundError as err:
-        raise GitNotInstalledError(
+        raise cv.Invalid(
             "git is not installed but required for external_components.\n"
             "Please see https://git-scm.com/book/en/v2/Getting-Started-Installing-Git for installing git"
         ) from err
@@ -80,8 +33,8 @@ def run_git_command(cmd: list[str], git_dir: Path | None = None) -> str:
         err_str = ret.stderr.decode("utf-8")
         lines = [x.strip() for x in err_str.splitlines()]
         if lines[-1].startswith("fatal:"):
-            raise GitCommandError(lines[-1][len("fatal: ") :])
-        raise GitCommandError(err_str)
+            raise cv.Invalid(lines[-1][len("fatal: ") :])
+        raise cv.Invalid(err_str)
 
     return ret.stdout.decode("utf-8").strip()
 
@@ -102,7 +55,6 @@ def clone_or_update(
     username: str = None,
     password: str = None,
     submodules: list[str] | None = None,
-    _recover_broken: bool = True,
 ) -> tuple[Path, Callable[[], None] | None]:
     key = f"{url}@{ref}"
 
@@ -123,15 +75,15 @@ def clone_or_update(
             # We need to fetch the PR branch first, otherwise git will complain
             # about missing objects
             _LOGGER.info("Fetching %s", ref)
-            run_git_command(["git", "fetch", "--", "origin", ref], git_dir=repo_dir)
-            run_git_command(["git", "reset", "--hard", "FETCH_HEAD"], git_dir=repo_dir)
+            run_git_command(["git", "fetch", "--", "origin", ref], str(repo_dir))
+            run_git_command(["git", "reset", "--hard", "FETCH_HEAD"], str(repo_dir))
 
         if submodules is not None:
             _LOGGER.info(
-                "Initializing submodules (%s) for %s", ", ".join(submodules), key
+                "Initialising submodules (%s) for %s", ", ".join(submodules), key
             )
             run_git_command(
-                ["git", "submodule", "update", "--init"] + submodules, git_dir=repo_dir
+                ["git", "submodule", "update", "--init"] + submodules, str(repo_dir)
             )
 
     else:
@@ -147,82 +99,32 @@ def clone_or_update(
             file_timestamp = Path(repo_dir / ".git" / "HEAD")
         age = datetime.now() - datetime.fromtimestamp(file_timestamp.stat().st_mtime)
         if refresh is None or age.total_seconds() > refresh.total_seconds:
-            # Try to update the repository, recovering from broken state if needed
-            old_sha: str | None = None
-            try:
-                # First verify the repository is valid by checking HEAD
-                # Use git_dir parameter to prevent git from walking up to parent repos
-                old_sha = run_git_command(
-                    ["git", "rev-parse", "HEAD"], git_dir=repo_dir
-                )
-
-                _LOGGER.info("Updating %s", key)
-                _LOGGER.debug("Location: %s", repo_dir)
-
-                # Stash local changes (if any)
-                # Use git_dir to ensure this only affects the specific repo
-                run_git_command(
-                    ["git", "stash", "push", "--include-untracked"],
-                    git_dir=repo_dir,
-                )
-
-                # Fetch remote ref
-                cmd = ["git", "fetch", "--", "origin"]
-                if ref is not None:
-                    cmd.append(ref)
-                run_git_command(cmd, git_dir=repo_dir)
-
-                # Hard reset to FETCH_HEAD (short-lived git ref corresponding to most recent fetch)
-                run_git_command(
-                    ["git", "reset", "--hard", "FETCH_HEAD"],
-                    git_dir=repo_dir,
-                )
-            except GitException as err:
-                # Repository is in a broken state or update failed
-                # Only attempt recovery once to prevent infinite recursion
-                if not _recover_broken:
-                    _LOGGER.error(
-                        "Repository %s recovery failed, cannot retry (already attempted once)",
-                        key,
-                    )
-                    raise
-
-                _LOGGER.warning(
-                    "Repository %s has issues (%s), attempting recovery",
-                    key,
-                    err,
-                )
-                _LOGGER.info("Removing broken repository at %s", repo_dir)
-                shutil.rmtree(repo_dir)
-                _LOGGER.info("Successfully removed broken repository, re-cloning...")
-
-                # Recursively call clone_or_update to re-clone
-                # Set _recover_broken=False to prevent infinite recursion
-                result = clone_or_update(
-                    url=url,
-                    ref=ref,
-                    refresh=refresh,
-                    domain=domain,
-                    username=username,
-                    password=password,
-                    submodules=submodules,
-                    _recover_broken=False,
-                )
-                _LOGGER.info("Repository %s successfully recovered", key)
-                return result
+            old_sha = run_git_command(["git", "rev-parse", "HEAD"], str(repo_dir))
+            _LOGGER.info("Updating %s", key)
+            _LOGGER.debug("Location: %s", repo_dir)
+            # Stash local changes (if any)
+            run_git_command(
+                ["git", "stash", "push", "--include-untracked"], str(repo_dir)
+            )
+            # Fetch remote ref
+            cmd = ["git", "fetch", "--", "origin"]
+            if ref is not None:
+                cmd.append(ref)
+            run_git_command(cmd, str(repo_dir))
+            # Hard reset to FETCH_HEAD (short-lived git ref corresponding to most recent fetch)
+            run_git_command(["git", "reset", "--hard", "FETCH_HEAD"], str(repo_dir))
 
             if submodules is not None:
                 _LOGGER.info(
                     "Updating submodules (%s) for %s", ", ".join(submodules), key
                 )
                 run_git_command(
-                    ["git", "submodule", "update", "--init"] + submodules,
-                    git_dir=repo_dir,
+                    ["git", "submodule", "update", "--init"] + submodules, str(repo_dir)
                 )
 
             def revert():
                 _LOGGER.info("Reverting changes to %s -> %s", key, old_sha)
-                run_git_command(["git", "reset", "--hard", old_sha], git_dir=repo_dir)
+                run_git_command(["git", "reset", "--hard", old_sha], str(repo_dir))
 
             return repo_dir, revert
 

esphome/platformio_api.py

@@ -145,7 +145,16 @@ def run_compile(config, verbose):
     args = []
     if CONF_COMPILE_PROCESS_LIMIT in config[CONF_ESPHOME]:
         args += [f"-j{config[CONF_ESPHOME][CONF_COMPILE_PROCESS_LIMIT]}"]
-    return run_platformio_cli_run(config, verbose, *args)
+    result = run_platformio_cli_run(config, verbose, *args)
+
+    # Run memory analysis if enabled
+    if config.get(CONF_ESPHOME, {}).get("analyze_memory", False):
+        try:
+            analyze_memory_usage(config)
+        except Exception as e:
+            _LOGGER.warning("Failed to analyze memory usage: %s", e)
+
+    return result
 
 
 def _run_idedata(config):
@@ -374,3 +383,93 @@ class IDEData:
             return f"{self.cc_path[:-7]}addr2line.exe"
 
         return f"{self.cc_path[:-3]}addr2line"
+
+    @property
+    def objdump_path(self) -> str:
+        # replace gcc at end with objdump
+
+        # Windows
+        if self.cc_path.endswith(".exe"):
+            return f"{self.cc_path[:-7]}objdump.exe"
+
+        return f"{self.cc_path[:-3]}objdump"
+
+    @property
+    def readelf_path(self) -> str:
+        # replace gcc at end with readelf
+
+        # Windows
+        if self.cc_path.endswith(".exe"):
+            return f"{self.cc_path[:-7]}readelf.exe"
+
+        return f"{self.cc_path[:-3]}readelf"
+
+
+def analyze_memory_usage(config: dict[str, Any]) -> None:
+    """Analyze memory usage by component after compilation."""
+    # Lazy import to avoid overhead when not needed
+    from esphome.analyze_memory import MemoryAnalyzer
+
+    idedata = get_idedata(config)
+
+    # Get paths to tools
+    elf_path = idedata.firmware_elf_path
+    objdump_path = idedata.objdump_path
+    readelf_path = idedata.readelf_path
+
+    # Debug logging
+    _LOGGER.debug("ELF path from idedata: %s", elf_path)
+
+    # Check if file exists
+    if not Path(elf_path).exists():
+        # Try alternate path
+        alt_path = Path(CORE.relative_build_path(".pioenvs", CORE.name, "firmware.elf"))
+        if alt_path.exists():
+            elf_path = str(alt_path)
+            _LOGGER.debug("Using alternate ELF path: %s", elf_path)
+        else:
+            _LOGGER.warning("ELF file not found at %s or %s", elf_path, alt_path)
+            return
+
+    # Extract external components from config
+    external_components = set()
+
+    # Get the list of built-in ESPHome components
+    from esphome.analyze_memory import get_esphome_components
+
+    builtin_components = get_esphome_components()
+
+    # Special non-component keys that appear in configs
+    NON_COMPONENT_KEYS = {
+        CONF_ESPHOME,
+        "substitutions",
+        "packages",
+        "globals",
+        "<<",
+    }
+
+    # Check all top-level keys in config
+    for key in config:
+        if key not in builtin_components and key not in NON_COMPONENT_KEYS:
+            # This is an external component
+            external_components.add(key)
+
+    _LOGGER.debug("Detected external components: %s", external_components)
+
+    # Create analyzer and run analysis
+    analyzer = MemoryAnalyzer(elf_path, objdump_path, readelf_path, external_components)
+    analyzer.analyze()
+
+    # Generate and print report
+    report = analyzer.generate_report()
+    _LOGGER.info("\n%s", report)
+
+    # Optionally save to file
+    if config.get(CONF_ESPHOME, {}).get("memory_report_file"):
+        report_file = Path(config[CONF_ESPHOME]["memory_report_file"])
+        if report_file.suffix == ".json":
+            report_file.write_text(analyzer.to_json())
+            _LOGGER.info("Memory report saved to %s", report_file)
+        else:
+            report_file.write_text(report)
+            _LOGGER.info("Memory report saved to %s", report_file)

requirements.txt

@@ -12,7 +12,7 @@ platformio==6.1.18  # When updating platformio, also update /docker/Dockerfile
 esptool==5.1.0
 click==8.1.7
 esphome-dashboard==20251013.0
-aioesphomeapi==41.18.0
+aioesphomeapi==41.17.0
 zeroconf==0.148.0
 puremagic==1.30
 ruamel.yaml==0.18.15 # dashboard_import

tests/unit_tests/conftest.py

@@ -96,13 +96,6 @@ def mock_run_git_command() -> Generator[Mock, None, None]:
         yield mock
 
 
-@pytest.fixture
-def mock_subprocess_run() -> Generator[Mock, None, None]:
-    """Mock subprocess.run for testing."""
-    with patch("subprocess.run") as mock:
-        yield mock
-
-
 @pytest.fixture
 def mock_get_idedata() -> Generator[Mock, None, None]:
     """Mock get_idedata for platformio_api."""

tests/unit_tests/test_core.py

@@ -661,3 +661,45 @@ class TestEsphomeCore:
             os.environ.pop("ESPHOME_IS_HA_ADDON", None)
             os.environ.pop("ESPHOME_DATA_DIR", None)
             assert target.data_dir == Path(expected_default)
+
+    def test_platformio_cache_dir_with_env_var(self):
+        """Test platformio_cache_dir when PLATFORMIO_CACHE_DIR env var is set."""
+        target = core.EsphomeCore()
+        test_cache_dir = "/custom/cache/dir"
+
+        with patch.dict(os.environ, {"PLATFORMIO_CACHE_DIR": test_cache_dir}):
+            assert target.platformio_cache_dir == test_cache_dir
+
+    def test_platformio_cache_dir_without_env_var(self):
+        """Test platformio_cache_dir defaults to ~/.platformio/.cache."""
+        target = core.EsphomeCore()
+
+        with patch.dict(os.environ, {}, clear=True):
+            # Ensure env var is not set
+            os.environ.pop("PLATFORMIO_CACHE_DIR", None)
+            expected = os.path.expanduser("~/.platformio/.cache")
+            assert target.platformio_cache_dir == expected
+
+    def test_platformio_cache_dir_empty_env_var(self):
+        """Test platformio_cache_dir with empty env var falls back to default."""
+        target = core.EsphomeCore()
+
+        with patch.dict(os.environ, {"PLATFORMIO_CACHE_DIR": ""}):
+            expected = os.path.expanduser("~/.platformio/.cache")
+            assert target.platformio_cache_dir == expected
+
+    def test_platformio_cache_dir_whitespace_env_var(self):
+        """Test platformio_cache_dir with whitespace-only env var falls back to default."""
+        target = core.EsphomeCore()
+
+        with patch.dict(os.environ, {"PLATFORMIO_CACHE_DIR": "   "}):
+            expected = os.path.expanduser("~/.platformio/.cache")
+            assert target.platformio_cache_dir == expected
+
+    def test_platformio_cache_dir_docker_addon_path(self):
+        """Test platformio_cache_dir in Docker/HA addon environment."""
+        target = core.EsphomeCore()
+        addon_cache = "/data/cache/platformio"
+
+        with patch.dict(os.environ, {"PLATFORMIO_CACHE_DIR": addon_cache}):
+            assert target.platformio_cache_dir == addon_cache

tests/unit_tests/test_git.py

@@ -1,204 +1,13 @@
 """Tests for git.py module."""
 
 from datetime import datetime, timedelta
+import hashlib
 import os
 from pathlib import Path
-from typing import Any
 from unittest.mock import Mock
 
-import pytest
-
 from esphome import git
 from esphome.core import CORE, TimePeriodSeconds
-from esphome.git import GitCommandError
-
-
-def _compute_repo_dir(url: str, ref: str | None, domain: str) -> Path:
-    """Helper to compute the expected repo directory path using git module's logic."""
-    key = f"{url}@{ref}"
-    return git._compute_destination_path(key, domain)
-
-
-def _setup_old_repo(repo_dir: Path, days_old: int = 2) -> None:
-    """Helper to set up a git repo directory structure with an old timestamp.
-
-    Args:
-        repo_dir: The repository directory path to create.
-        days_old: Number of days old to make the FETCH_HEAD file (default: 2).
-    """
-    # Create repo directory
-    repo_dir.mkdir(parents=True)
-    git_dir = repo_dir / ".git"
-    git_dir.mkdir()
-
-    # Create FETCH_HEAD file with old timestamp
-    fetch_head = git_dir / "FETCH_HEAD"
-    fetch_head.write_text("test")
-    old_time = datetime.now() - timedelta(days=days_old)
-    fetch_head.touch()
-    os.utime(fetch_head, (old_time.timestamp(), old_time.timestamp()))
-
-
-def _get_git_command_type(cmd: list[str]) -> str | None:
-    """Helper to determine the type of git command from a command list.
-
-    Args:
-        cmd: The git command list (e.g., ["git", "rev-parse", "HEAD"]).
-
-    Returns:
-        The command type ("rev-parse", "stash", "fetch", "reset", "clone") or None.
-    """
-    # Git commands are always in format ["git", "command", ...], so check index 1
-    if len(cmd) > 1:
-        return cmd[1]
-    return None
-
-
-def test_run_git_command_success(tmp_path: Path) -> None:
-    """Test that run_git_command returns output on success."""
-    # Create a simple git repo to test with
-    repo_dir = tmp_path / "test_repo"
-    repo_dir.mkdir()
-
-    # Initialize a git repo
-    result = git.run_git_command(["git", "init"], str(repo_dir))
-    assert "Initialized empty Git repository" in result or result == ""
-
-    # Verify we can run a command and get output
-    result = git.run_git_command(["git", "status", "--porcelain"], str(repo_dir))
-    # Empty repo should have empty status
-    assert isinstance(result, str)
-
-
-def test_run_git_command_with_git_dir_isolation(
-    tmp_path: Path, mock_subprocess_run: Mock
-) -> None:
-    """Test that git_dir parameter properly isolates git operations."""
-    repo_dir = tmp_path / "test_repo"
-    repo_dir.mkdir()
-    git_dir = repo_dir / ".git"
-    git_dir.mkdir()
-
-    # Configure mock to return success
-    mock_subprocess_run.return_value = Mock(
-        returncode=0,
-        stdout=b"test output",
-        stderr=b"",
-    )
-
-    result = git.run_git_command(
-        ["git", "rev-parse", "HEAD"],
-        git_dir=repo_dir,
-    )
-
-    # Verify subprocess.run was called
-    assert mock_subprocess_run.called
-    call_args = mock_subprocess_run.call_args
-
-    # Verify environment was set
-    env = call_args[1]["env"]
-    assert "GIT_DIR" in env
-    assert "GIT_WORK_TREE" in env
-    assert env["GIT_DIR"] == str(repo_dir / ".git")
-    assert env["GIT_WORK_TREE"] == str(repo_dir)
-
-    assert result == "test output"
-
-
-def test_run_git_command_raises_git_not_installed_error(
-    tmp_path: Path, mock_subprocess_run: Mock
-) -> None:
-    """Test that FileNotFoundError is converted to GitNotInstalledError."""
-    from esphome.git import GitNotInstalledError
-
-    repo_dir = tmp_path / "test_repo"
-
-    # Configure mock to raise FileNotFoundError
-    mock_subprocess_run.side_effect = FileNotFoundError("git not found")
-
-    with pytest.raises(GitNotInstalledError, match="git is not installed"):
-        git.run_git_command(["git", "status"], git_dir=repo_dir)
-
-
-def test_run_git_command_raises_git_command_error_on_failure(
-    tmp_path: Path, mock_subprocess_run: Mock
-) -> None:
-    """Test that failed git commands raise GitCommandError."""
-    repo_dir = tmp_path / "test_repo"
-
-    # Configure mock to return non-zero exit code
-    mock_subprocess_run.return_value = Mock(
-        returncode=1,
-        stdout=b"",
-        stderr=b"fatal: not a git repository",
-    )
-
-    with pytest.raises(GitCommandError, match="not a git repository"):
-        git.run_git_command(["git", "status"], git_dir=repo_dir)
-
-
-def test_run_git_command_strips_fatal_prefix(
-    tmp_path: Path, mock_subprocess_run: Mock
-) -> None:
-    """Test that 'fatal: ' prefix is stripped from error messages."""
-    repo_dir = tmp_path / "test_repo"
-
-    # Configure mock to return error with "fatal: " prefix
-    mock_subprocess_run.return_value = Mock(
-        returncode=128,
-        stdout=b"",
-        stderr=b"fatal: repository not found\n",
-    )
-
-    with pytest.raises(GitCommandError) as exc_info:
-        git.run_git_command(["git", "clone", "invalid-url"], git_dir=repo_dir)
-
-    # Error message should NOT include "fatal: " prefix
-    assert "fatal:" not in str(exc_info.value)
-    assert "repository not found" in str(exc_info.value)
-
-
-def test_run_git_command_without_git_dir(mock_subprocess_run: Mock) -> None:
-    """Test that run_git_command works without git_dir (clone case)."""
-    # Configure mock to return success
-    mock_subprocess_run.return_value = Mock(
-        returncode=0,
-        stdout=b"Cloning into 'test_repo'...",
-        stderr=b"",
-    )
-
-    result = git.run_git_command(["git", "clone", "https://github.com/test/repo"])
-
-    # Verify subprocess.run was called
-    assert mock_subprocess_run.called
-    call_args = mock_subprocess_run.call_args
-
-    # Verify environment does NOT have GIT_DIR or GIT_WORK_TREE set
-    # (it should use the default environment or None)
-    env = call_args[1].get("env")
-    if env is not None:
-        assert "GIT_DIR" not in env
-        assert "GIT_WORK_TREE" not in env
-
-    # Verify cwd is None (default)
-    assert call_args[1].get("cwd") is None
-
-    assert result == "Cloning into 'test_repo'..."
-
-
-def test_run_git_command_without_git_dir_raises_error(
-    mock_subprocess_run: Mock,
-) -> None:
-    """Test that run_git_command without git_dir can still raise errors."""
-    # Configure mock to return error
-    mock_subprocess_run.return_value = Mock(
-        returncode=128,
-        stdout=b"",
-        stderr=b"fatal: repository not found\n",
-    )
-
-    with pytest.raises(GitCommandError, match="repository not found"):
-        git.run_git_command(["git", "clone", "https://invalid.url/repo.git"])
 
 
 def test_clone_or_update_with_never_refresh(
@@ -208,10 +17,16 @@ def test_clone_or_update_with_never_refresh(
     # Set up CORE.config_path so data_dir uses tmp_path
     CORE.config_path = tmp_path / "test.yaml"
 
+    # Compute the expected repo directory path
     url = "https://github.com/test/repo"
     ref = None
+    key = f"{url}@{ref}"
     domain = "test"
-    repo_dir = _compute_repo_dir(url, ref, domain)
+
+    # Compute hash-based directory name (matching _compute_destination_path logic)
+    h = hashlib.new("sha256")
+    h.update(key.encode())
+    repo_dir = tmp_path / ".esphome" / domain / h.hexdigest()[:8]
 
     # Create the git repo directory structure
     repo_dir.mkdir(parents=True)
@@ -243,10 +58,16 @@ def test_clone_or_update_with_refresh_updates_old_repo(
     # Set up CORE.config_path so data_dir uses tmp_path
     CORE.config_path = tmp_path / "test.yaml"
 
+    # Compute the expected repo directory path
     url = "https://github.com/test/repo"
     ref = None
+    key = f"{url}@{ref}"
     domain = "test"
-    repo_dir = _compute_repo_dir(url, ref, domain)
+
+    # Compute hash-based directory name (matching _compute_destination_path logic)
+    h = hashlib.new("sha256")
+    h.update(key.encode())
+    repo_dir = tmp_path / ".esphome" / domain / h.hexdigest()[:8]
 
     # Create the git repo directory structure
     repo_dir.mkdir(parents=True)
@@ -291,10 +112,16 @@ def test_clone_or_update_with_refresh_skips_fresh_repo(
     # Set up CORE.config_path so data_dir uses tmp_path
     CORE.config_path = tmp_path / "test.yaml"
 
+    # Compute the expected repo directory path
     url = "https://github.com/test/repo"
     ref = None
+    key = f"{url}@{ref}"
     domain = "test"
-    repo_dir = _compute_repo_dir(url, ref, domain)
+
+    # Compute hash-based directory name (matching _compute_destination_path logic)
+    h = hashlib.new("sha256")
+    h.update(key.encode())
+    repo_dir = tmp_path / ".esphome" / domain / h.hexdigest()[:8]
 
     # Create the git repo directory structure
     repo_dir.mkdir(parents=True)
@@ -331,10 +158,16 @@ def test_clone_or_update_clones_missing_repo(
     # Set up CORE.config_path so data_dir uses tmp_path
     CORE.config_path = tmp_path / "test.yaml"
 
+    # Compute the expected repo directory path
     url = "https://github.com/test/repo"
     ref = None
+    key = f"{url}@{ref}"
     domain = "test"
-    repo_dir = _compute_repo_dir(url, ref, domain)
+
+    # Compute hash-based directory name (matching _compute_destination_path logic)
+    h = hashlib.new("sha256")
+    h.update(key.encode())
+    repo_dir = tmp_path / ".esphome" / domain / h.hexdigest()[:8]
 
     # Create base directory but NOT the repo itself
     base_dir = tmp_path / ".esphome" / domain
@@ -367,10 +200,16 @@ def test_clone_or_update_with_none_refresh_always_updates(
     # Set up CORE.config_path so data_dir uses tmp_path
     CORE.config_path = tmp_path / "test.yaml"
 
+    # Compute the expected repo directory path
     url = "https://github.com/test/repo"
     ref = None
+    key = f"{url}@{ref}"
     domain = "test"
-    repo_dir = _compute_repo_dir(url, ref, domain)
+
+    # Compute hash-based directory name (matching _compute_destination_path logic)
+    h = hashlib.new("sha256")
+    h.update(key.encode())
+    repo_dir = tmp_path / ".esphome" / domain / h.hexdigest()[:8]
 
     # Create the git repo directory structure
     repo_dir.mkdir(parents=True)
@@ -405,269 +244,3 @@ def test_clone_or_update_with_none_refresh_always_updates(
         if len(call[0]) > 0 and "fetch" in call[0][0]
     ]
     assert len(fetch_calls) > 0
-
-
-@pytest.mark.parametrize(
-    ("fail_command", "error_message"),
-    [
-        (
-            "rev-parse",
-            "ambiguous argument 'HEAD': unknown revision or path not in the working tree.",
-        ),
-        ("stash", "fatal: unable to write new index file"),
-        (
-            "fetch",
-            "fatal: unable to access 'https://github.com/test/repo/': Could not resolve host",
-        ),
-        ("reset", "fatal: Could not reset index file to revision 'FETCH_HEAD'"),
-    ],
-)
-def test_clone_or_update_recovers_from_git_failures(
-    tmp_path: Path, mock_run_git_command: Mock, fail_command: str, error_message: str
-) -> None:
-    """Test that repos are re-cloned when various git commands fail."""
-    # Set up CORE.config_path so data_dir uses tmp_path
-    CORE.config_path = tmp_path / "test.yaml"
-
-    url = "https://github.com/test/repo"
-    ref = "main"
-    domain = "test"
-    repo_dir = _compute_repo_dir(url, ref, domain)
-
-    # Use helper to set up old repo
-    _setup_old_repo(repo_dir)
-
-    # Track command call counts to make first call fail, subsequent calls succeed
-    call_counts: dict[str, int] = {}
-
-    def git_command_side_effect(
-        cmd: list[str], cwd: str | None = None, **kwargs: Any
-    ) -> str:
-        # Determine which command this is
-        cmd_type = _get_git_command_type(cmd)
-
-        # Track call count for this command type
-        if cmd_type:
-            call_counts[cmd_type] = call_counts.get(cmd_type, 0) + 1
-
-        # Fail on first call to the specified command, succeed on subsequent calls
-        if cmd_type == fail_command and call_counts[cmd_type] == 1:
-            raise GitCommandError(error_message)
-
-        # Default successful responses
-        if cmd_type == "rev-parse":
-            return "abc123"
-        return ""
-
-    mock_run_git_command.side_effect = git_command_side_effect
-
-    refresh = TimePeriodSeconds(days=1)
-    result_dir, revert = git.clone_or_update(
-        url=url,
-        ref=ref,
-        refresh=refresh,
-        domain=domain,
-    )
-
-    # Verify recovery happened
-    call_list = mock_run_git_command.call_args_list
-
-    # Should have attempted the failing command
-    assert any(fail_command in str(c) for c in call_list)
-
-    # Should have called clone for recovery
-    assert any("clone" in str(c) for c in call_list)
-
-    # Verify the repo directory path is returned
-    assert result_dir == repo_dir
-
-
-def test_clone_or_update_fails_when_recovery_also_fails(
-    tmp_path: Path, mock_run_git_command: Mock
-) -> None:
-    """Test that we don't infinitely recurse when recovery also fails."""
-    # Set up CORE.config_path so data_dir uses tmp_path
-    CORE.config_path = tmp_path / "test.yaml"
-
-    url = "https://github.com/test/repo"
-    ref = "main"
-    domain = "test"
-    repo_dir = _compute_repo_dir(url, ref, domain)
-
-    # Use helper to set up old repo
-    _setup_old_repo(repo_dir)
-
-    # Mock git command to fail on clone (simulating network failure during recovery)
-    def git_command_side_effect(
-        cmd: list[str], cwd: str | None = None, **kwargs: Any
-    ) -> str:
-        cmd_type = _get_git_command_type(cmd)
-        if cmd_type == "rev-parse":
-            # First time fails (broken repo)
-            raise GitCommandError(
-                "ambiguous argument 'HEAD': unknown revision or path not in the working tree."
-            )
-        if cmd_type == "clone":
-            # Clone also fails (recovery fails)
-            raise GitCommandError("fatal: unable to access repository")
-        return ""
-
-    mock_run_git_command.side_effect = git_command_side_effect
-
-    refresh = TimePeriodSeconds(days=1)
-
-    # Should raise after one recovery attempt fails
-    with pytest.raises(GitCommandError, match="fatal: unable to access repository"):
-        git.clone_or_update(
-            url=url,
-            ref=ref,
-            refresh=refresh,
-            domain=domain,
-        )
-
-    # Verify we only tried to clone once (no infinite recursion)
-    call_list = mock_run_git_command.call_args_list
-    clone_calls = [c for c in call_list if "clone" in c[0][0]]
-    # Should have exactly one clone call (the recovery attempt that failed)
-    assert len(clone_calls) == 1
-    # Should have tried rev-parse once (which failed and triggered recovery)
-    rev_parse_calls = [c for c in call_list if "rev-parse" in c[0][0]]
-    assert len(rev_parse_calls) == 1
-
-
-def test_clone_or_update_recover_broken_flag_prevents_second_recovery(
-    tmp_path: Path, mock_run_git_command: Mock
-) -> None:
-    """Test that _recover_broken=False prevents a second recovery attempt (tests the raise path)."""
-    # Set up CORE.config_path so data_dir uses tmp_path
-    CORE.config_path = tmp_path / "test.yaml"
-
-    url = "https://github.com/test/repo"
-    ref = "main"
-    domain = "test"
-    repo_dir = _compute_repo_dir(url, ref, domain)
-
-    # Use helper to set up old repo
-    _setup_old_repo(repo_dir)
-
-    # Track fetch calls to differentiate between first (in clone) and second (in recovery update)
-    call_counts: dict[str, int] = {}
-
-    # Mock git command to fail on fetch during recovery's ref checkout
-    def git_command_side_effect(
-        cmd: list[str], cwd: str | None = None, **kwargs: Any
-    ) -> str:
-        cmd_type = _get_git_command_type(cmd)
-
-        if cmd_type:
-            call_counts[cmd_type] = call_counts.get(cmd_type, 0) + 1
-
-        # First attempt: rev-parse fails (broken repo)
-        if cmd_type == "rev-parse" and call_counts[cmd_type] == 1:
-            raise GitCommandError(
-                "ambiguous argument 'HEAD': unknown revision or path not in the working tree."
-            )
-
-        # Recovery: clone succeeds
-        if cmd_type == "clone":
-            return ""
-
-        # Recovery: fetch for ref checkout fails
-        # This happens in the clone path when ref is not None (line 80 in git.py)
-        if cmd_type == "fetch" and call_counts[cmd_type] == 1:
-            raise GitCommandError("fatal: couldn't find remote ref main")
-
-        # Default success
-        return "abc123" if cmd_type == "rev-parse" else ""
-
-    mock_run_git_command.side_effect = git_command_side_effect
-
-    refresh = TimePeriodSeconds(days=1)
-
-    # Should raise on the fetch during recovery (when _recover_broken=False)
-    # This tests the critical "if not _recover_broken: raise" path
-    with pytest.raises(GitCommandError, match="fatal: couldn't find remote ref main"):
-        git.clone_or_update(
-            url=url,
-            ref=ref,
-            refresh=refresh,
-            domain=domain,
-        )
-
-    # Verify the sequence of events
-    call_list = mock_run_git_command.call_args_list
-
-    # Should have: rev-parse (fail, triggers recovery), clone (success),
-    # fetch (fail during ref checkout, raises because _recover_broken=False)
-    rev_parse_calls = [c for c in call_list if "rev-parse" in c[0][0]]
-    # Should have exactly one rev-parse call that failed
-    assert len(rev_parse_calls) == 1
-
-    clone_calls = [c for c in call_list if "clone" in c[0][0]]
-    # Should have exactly one clone call (the recovery attempt)
-    assert len(clone_calls) == 1
-
-    fetch_calls = [c for c in call_list if "fetch" in c[0][0]]
-    # Should have exactly one fetch call that failed (during ref checkout in recovery)
-    assert len(fetch_calls) == 1
-
-
-def test_clone_or_update_recover_broken_flag_prevents_infinite_loop(
-    tmp_path: Path, mock_run_git_command: Mock
-) -> None:
-    """Test that _recover_broken=False prevents infinite recursion when repo persists."""
-    # This tests the critical "if not _recover_broken: raise" path at line 124-125
-    # Set up CORE.config_path so data_dir uses tmp_path
-    CORE.config_path = tmp_path / "test.yaml"
-
-    url = "https://github.com/test/repo"
-    ref = "main"
-    domain = "test"
-    repo_dir = _compute_repo_dir(url, ref, domain)
-
-    # Use helper to set up old repo
-    _setup_old_repo(repo_dir)
-
-    # Mock shutil.rmtree to NOT actually delete the directory
-    # This simulates a scenario where deletion fails (permissions, etc.)
-    import unittest.mock
-
-    def mock_rmtree(path, *args, **kwargs):
-        # Don't actually delete - this causes the recursive call to still see the repo
-        pass
-
-    # Mock git commands to always fail on stash
-    def git_command_side_effect(
-        cmd: list[str], cwd: str | None = None, **kwargs: Any
-    ) -> str:
-        cmd_type = _get_git_command_type(cmd)
-        if cmd_type == "rev-parse":
-            return "abc123"
-        if cmd_type == "stash":
-            # Always fails
-            raise GitCommandError("fatal: unable to write new index file")
-        return ""
-
-    mock_run_git_command.side_effect = git_command_side_effect
-
-    refresh = TimePeriodSeconds(days=1)
-
-    # Mock shutil.rmtree and test
-    # Should raise on the second attempt when _recover_broken=False
-    # This hits the "if not _recover_broken: raise" path
-    with (
-        unittest.mock.patch("esphome.git.shutil.rmtree", side_effect=mock_rmtree),
-        pytest.raises(GitCommandError, match="fatal: unable to write new index file"),
-    ):
-        git.clone_or_update(
-            url=url,
-            ref=ref,
-            refresh=refresh,
-            domain=domain,
-        )
-
-    # Verify the sequence: stash fails twice (once triggering recovery, once raising)
-    call_list = mock_run_git_command.call_args_list
-    stash_calls = [c for c in call_list if "stash" in c[0][0]]
-    # Should have exactly two stash calls
-    assert len(stash_calls) == 2

tests/unit_tests/test_writer.py

@@ -355,6 +355,7 @@ def test_clean_build(
     mock_core.relative_pioenvs_path.return_value = pioenvs_dir
     mock_core.relative_piolibdeps_path.return_value = piolibdeps_dir
     mock_core.relative_build_path.return_value = dependencies_lock
+    mock_core.platformio_cache_dir = str(platformio_cache_dir)
 
     # Verify all exist before
     assert pioenvs_dir.exists()