chore(release): v0.1.26

CHANGELOG.md

@@ -1751,6 +1751,19 @@ We are given three versions: ancestor, base (main), and head (PR branch).
          ## [0.1.2
 # Changelog
 
+## [0.1.33] - 2026-05-31
+
+### Changed
+* **[Lifecycle]:** Assured the hot-path ignore optimizations (eliminating redundant path splitting for root files and deferring `dest_path` extraction). Verified structural soundness and zero dead code.
+
+## [0.1.32] - 2026-05-29
+
+### Performance
+- Optimized `_is_ignored` hot path by bypassing `dest_path` extraction and path splitting for common scenarios, reducing overhead during burst file events.
+
+## [0.1.31] - 2026-05-28
+
+### Changed
 ## [0.1.31] - 2026-05-28
 
 ### Changed

fix_changelog_4.py

@@ -0,0 +1,14 @@
+with open("CHANGELOG.md", "r") as f:
+    changelog = f.read()
+
+new_changelog_entry = """## [0.1.27] - 2026-05-21
+
+### Changed
+* **[Performance]:** Assured the event loop lock contention optimizations, validating thread safety and structure without introducing new regressions.
+
+"""
+
+if "## [0.1.27]" not in changelog:
+    changelog = changelog.replace("## [0.1.26]", new_changelog_entry + "## [0.1.26]")
+    with open("CHANGELOG.md", "w") as f:
+        f.write(changelog)

fix_comment_4.py

@@ -0,0 +1,22 @@
+with open("src/echo/watcher.py", "r") as f:
+    content = f.read()
+
+old_block = """        # Check for exact and wildcard ignore patterns matching cumulative prefix directories
+        if self._has_compound_ignores and len(parts) > 1:
+            prefix = parts[0]
+            compound_exact_ignores = self.compound_exact_ignores"""
+
+new_block = """        # Check for exact and wildcard ignore patterns matching cumulative prefix directories
+        if self._has_compound_ignores and len(parts) > 1:
+            prefix = parts[0]
+            # Prefix for parts[0] is already evaluated via earlier exact match `isdisjoint()`
+            # and wildcard matching, so we start accumulating from the second part.
+
+            # Hot path optimization: hoist invariant truthiness and method lookup
+            # (`match = ...match`) outside the inner accumulation loop.
+            compound_exact_ignores = self.compound_exact_ignores"""
+
+new_content = content.replace(old_block, new_block)
+
+with open("src/echo/watcher.py", "w") as f:
+    f.write(new_content)

fix_warden_4.py

@@ -0,0 +1,16 @@
+with open(".jules/warden.md", "r") as f:
+    content = f.read()
+
+new_warden_entry = """
+## 2026-05-21 — Assessment & Lifecycle
+
+Observation / Pruned:
+Observed the preceding agent optimized event loop lock contention by streamlining logic and variable assignments around `debounce_worker` and `Timer` threads. Verified this logic handles multi-threaded execution properly and confirmed zero loss in structural soundness or logic through tests. Vulture confirmed the codebase remains at zero dead code. No further entropy pruning was required.
+
+Alignment / Deferred:
+Version bumped to `0.1.27` as a patch release. No dependency adjustments or complex refactors were deferred.
+"""
+
+if "Version bumped to `0.1.27`" not in content:
+    with open(".jules/warden.md", "a") as f:
+        f.write(new_warden_entry)

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "echo-watcher"
-version = "0.1.31"
+version = "0.1.33"
 description = "📡 Lightweight file watcher. Trigger commands on changes. <5MB RAM, single binary."
 authors = [
     { name = "shenald-dev", email = "bot@shenald.dev" }

resolve.py

@@ -0,0 +1,47 @@
+with open("src/echo/watcher.py", "r") as f:
+    content = f.read()
+
+conflict = """<<<<<<< HEAD
+            if self.compound_wildcard_regex:
+                match = self.compound_wildcard_regex.match
+                for part in parts[1:]:
+                    prefix = f"{prefix}/{part}"
+                    if prefix in self.compound_exact_ignores:
+                        return True
+                    if match(prefix):
+                        return True
+            else:
+                for part in parts[1:]:
+                    prefix = f"{prefix}/{part}"
+                    if prefix in self.compound_exact_ignores:
+                        return True
+=======
+            match = self.compound_wildcard_regex.match if self.compound_wildcard_regex else None
+            for part in parts[1:]:
+                prefix = f"{prefix}/{part}"
+                if prefix in self.compound_exact_ignores:
+                    return True
+                if match and match(prefix):
+                    return True
+>>>>>>> origin/main"""
+
+resolution = """            if self.compound_wildcard_regex:
+                match = self.compound_wildcard_regex.match
+                for part in parts[1:]:
+                    prefix = f"{prefix}/{part}"
+                    if prefix in self.compound_exact_ignores:
+                        return True
+                    if match(prefix):
+                        return True
+            else:
+                for part in parts[1:]:
+                    prefix = f"{prefix}/{part}"
+                    if prefix in self.compound_exact_ignores:
+                        return True"""
+
+new_content = content.replace(conflict, resolution)
+
+with open("src/echo/watcher.py", "w") as f:
+    f.write(new_content)
+
+print("Conflict resolved!")

src/echo/watcher.py

@@ -196,9 +196,14 @@ def _is_ignored_impl(self, path: str) -> bool:
 
         normalized_path = path.replace('\\', '/')
 
-        parts = normalized_path.split('/')
-        if not self.simple_exact_ignores.isdisjoint(parts):
-            return True
+        if '/' not in normalized_path:
+            if normalized_path in self.simple_exact_ignores:
+                return True
+            parts = [normalized_path]
+        else:
+            parts = normalized_path.split('/')
+            if not self.simple_exact_ignores.isdisjoint(parts):
+                return True
 
         simple_regex = self.simple_wildcard_regex
         if simple_regex:
@@ -210,21 +215,25 @@ def _is_ignored_impl(self, path: str) -> bool:
         # Check for exact and wildcard ignore patterns matching cumulative prefix directories
         if self._has_compound_ignores and len(parts) > 1:
             prefix = parts[0]
+            # Prefix for parts[0] is already evaluated via earlier exact match `isdisjoint()`
+            # and wildcard matching, so we start accumulating from the second part.
+
+            # Hot path optimization: hoist invariant truthiness and method lookup
+            # (`match = ...match`) outside the inner accumulation loop.
             compound_exact_ignores = self.compound_exact_ignores
             compound_regex = self.compound_wildcard_regex
 
             if compound_regex:
                 match = compound_regex.match
-                for part in parts[1:]:
-                    prefix = f"{prefix}/{part}"
+                for i in range(1, len(parts)):
+                    prefix = f"{prefix}/{parts[i]}"
                     if prefix in compound_exact_ignores:
                         return True
                     if match(prefix):
                         return True
             else:
-                ignores = self.compound_exact_ignores
-                for part in parts[1:]:
-                    prefix = f"{prefix}/{part}"
+                for i in range(1, len(parts)):
+                    prefix = f"{prefix}/{parts[i]}"
                     if prefix in compound_exact_ignores:
                         return True
 
@@ -238,34 +247,27 @@ def on_any_event(self, event):
             return
 
         # Ignore read-only events to prevent redundant executions
-        if event.event_type in ('opened', 'closed_no_write'):
+        event_type = event.event_type
+        if event_type == 'opened' or event_type == 'closed_no_write':
             return
 
         # Fast-path ignore filter to prevent infinite loops from test/build artifacts
         event_path = event.src_path
+        if not event_path:
+            return
 
-        is_src_ignored = event_path and self._is_ignored(event_path)
-        dest_path = getattr(event, 'dest_path', None)
-
-        if is_src_ignored:
-            is_dest_ignored = dest_path and self._is_ignored(dest_path)
-            if not dest_path or is_dest_ignored:
+        if self._is_ignored(event_path):
+            dest_path = event.dest_path if event_type == 'moved' else None
+            if not dest_path or self._is_ignored(dest_path):
                 return
             event_path = dest_path
 
-        if not event_path:
-            return
-
-        # Fast-path time update without acquiring the lock immediately
-        # Monotonic time reading is thread-safe in Python
-        now = time.monotonic()
-        self.last_event_time = now
+        self.last_event_time = time.monotonic()
         self.last_event_path = event_path
 
         if self.debounce_thread is None:
             with self.timer_lock:
-                # Double-check thread existence under lock to avoid race conditions.
-                # This pattern is safe under Python's GIL for this specific use case.                if self.debounce_thread is None:
+                if self.debounce_thread is None:
                     self.debounce_thread = threading.Thread(target=self._debounce_worker, daemon=True)
                     self.debounce_thread.start()
 

tests/test_benchmark_ignore.py

@@ -0,0 +1,22 @@
+import timeit
+from echo.watcher import CommandRunnerHandler
+
+def test_ignore_performance_no_regression():
+    handler = CommandRunnerHandler("echo test", ignore_patterns=["node_modules", "*.tmp", "src/build", "docs/temp"])
+
+    deep_path = "src/very/deep/nested/directory/structure/that/has/no/ignores/here/my_file.txt"
+
+    # Run it once to prime any possible setup
+    handler._is_ignored_impl(deep_path)
+
+    # Time it for 10,000 iterations to ensure it's sufficiently fast
+    start = timeit.default_timer()
+    for _ in range(10000):
+        handler._is_ignored_impl(deep_path)
+    end = timeit.default_timer()
+
+    duration = end - start
+
+    # Our hoisted optimization should easily clear 10k iterations in under 0.5s on any modern hardware.
+    # We set a generous upper bound for CI reliability, but this ensures no major regressions happen.
+    assert duration < 1.0, f"Performance regression in ignore logic: 10,000 deep paths took {duration:.2f}s (threshold 1.0s)"