Skip to content

Agent Zero AI framework

File Tree: fixed handling of limits

Rafael Uzarowski03cc663ac3ba
diff --git a/python/helpers/file_tree.py b/python/helpers/file_tree.py
index 485589aab..8d94dba98 100644
--- a/python/helpers/file_tree.py
+++ b/python/helpers/file_tree.py
@@ -70,7 +70,9 @@ def file_tree(
Notes:
* The utility is synchronous; avoid calling from latency-sensitive async loops.
* The ASCII renderer walks the established tree depth-first so connectors reflect parent/child structure,
- while traversal and limit calculations remain breadth-first by depth.
+ while traversal and limit calculations remain breadth-first by depth. When ``max_lines`` is set, the number
+ of non-comment entries (excluding the root banner) never exceeds that limit; informational summary comments
+ are emitted in addition when necessary.
* ``created`` and ``modified`` values in structured outputs are timezone-aware UTC
:class:`datetime.datetime` objects::
@@ -115,7 +117,8 @@ def file_tree(
queue: deque[tuple[_TreeEntry, str, int]] = deque([(root_node, abs_root, 1)])
nodes_in_order: list[_TreeEntry] = []
- limit_level: Optional[int] = None
+ rendered_count = 0
+ limit_reached = False
visibility_cache: dict[str, bool] = {}
def make_entry(entry: os.DirEntry, parent: _TreeEntry, level: int, item_type: Literal["file", "folder"]) -> _TreeEntry:
@@ -133,7 +136,7 @@ def file_tree(
rel_path=rel_posix,
)
- while queue:
+ while queue and not limit_reached:
parent_node, current_dir, level = queue.popleft()
if max_depth and level > max_depth:
@@ -161,35 +164,63 @@ def file_tree(
directory_node=parent_node,
)
- parent_node.items = children
- nodes_in_order.extend(children)
-
- if max_lines and limit_level is None and len(nodes_in_order) >= max_lines:
- limit_level = level
-
- for child in children:
+ trimmed_children: list[_TreeEntry] = []
+ hidden_children_local: list[_TreeEntry] = []
+ if max_lines and rendered_count >= max_lines:
+ limit_reached = True
+ hidden_children_local = children
+ else:
+ for index, child in enumerate(children):
+ if max_lines and rendered_count >= max_lines:
+ limit_reached = True
+ hidden_children_local = children[index:]
+ break
+ trimmed_children.append(child)
+ nodes_in_order.append(child)
+ is_global_summary = (
+ child.item_type == "comment"
+ and child.rel_path.endswith("#summary:limit")
+ )
+ if not is_global_summary:
+ rendered_count += 1
+ if limit_reached and hidden_children_local:
+ summary = _create_global_limit_comment(
+ parent_node,
+ hidden_children_local,
+ )
+ trimmed_children.append(summary)
+ nodes_in_order.append(summary)
+
+ parent_node.items = trimmed_children or None
+
+ if limit_reached:
+ break
+
+ for child in trimmed_children:
if child.item_type != "folder":
continue
if max_depth and level >= max_depth:
continue
- if limit_level is not None and level >= limit_level:
- continue
child_abs = os.path.join(current_dir, child.name)
queue.append((child, child_abs, level + 1))
- pruned_nodes: list[_TreeEntry] = nodes_in_order
- if max_lines and limit_level is not None:
- _prune_nested_children(
- root_node,
- lambda entry: entry.level <= limit_level,
- )
- pruned_nodes = [node for node in nodes_in_order if node.level <= limit_level]
+ remaining_queue = list(queue) if limit_reached else []
+ queue.clear()
- visible_nodes: list[_TreeEntry]
- if max_lines and limit_level is None:
- visible_nodes = pruned_nodes[:max_lines]
- else:
- visible_nodes = pruned_nodes
+ if limit_reached and remaining_queue:
+ for folder_node, folder_path, _ in remaining_queue:
+ summary = _create_folder_unprocessed_comment(
+ folder_node,
+ folder_path,
+ abs_root,
+ ignore_spec,
+ )
+ if summary is None:
+ continue
+ folder_node.items = (folder_node.items or []) + [summary]
+ nodes_in_order.append(summary)
+
+ visible_nodes = nodes_in_order
visible_ids = {id(node) for node in visible_nodes}
if visible_ids:
@@ -320,15 +351,84 @@ def _create_summary_comment(parent: _TreeEntry, noun: str, count: int) -> _TreeE
)
-def _prune_nested_children(node: _TreeEntry, predicate: Callable[[_TreeEntry], bool]) -> None:
- if node.items is None:
- return
- pruned: list[_TreeEntry] = []
- for child in node.items:
- if predicate(child):
- _prune_nested_children(child, predicate)
- pruned.append(child)
- node.items = pruned
+def _create_global_limit_comment(parent: _TreeEntry, hidden_children: Sequence[_TreeEntry]) -> _TreeEntry:
+ folders = sum(1 for child in hidden_children if child.item_type == "folder")
+ files = sum(1 for child in hidden_children if child.item_type == "file")
+ parts: list[str] = []
+ if folders:
+ label = "folder" if folders == 1 else "folders"
+ parts.append(f"{folders} {label}")
+ if files:
+ label = "file" if files == 1 else "files"
+ parts.append(f"{files} {label}")
+ if not parts:
+ remaining = len(hidden_children)
+ label = "item" if remaining == 1 else "items"
+ parts.append(f"{remaining} {label}")
+ label_text = ", ".join(parts)
+ return _TreeEntry(
+ name=f"limit reached – hidden: {label_text}",
+ level=parent.level + 1,
+ item_type="comment",
+ created=parent.created,
+ modified=parent.modified,
+ parent=parent,
+ items=None,
+ rel_path=f"{parent.rel_path}#summary:limit",
+ )
+
+
+def _create_folder_unprocessed_comment(
+ folder_node: _TreeEntry,
+ folder_path: str,
+ abs_root: str,
+ ignore_spec: Optional[PathSpec],
+) -> Optional[_TreeEntry]:
+ try:
+ folders, files = _list_directory_children(
+ folder_path,
+ abs_root,
+ ignore_spec,
+ max_depth_remaining=-1,
+ cache={},
+ )
+ except FileNotFoundError:
+ return None
+
+ hidden_entries: list[_TreeEntry] = []
+ for entry in folders:
+ stat = entry.stat(follow_symlinks=False)
+ hidden_entries.append(
+ _TreeEntry(
+ name=entry.name,
+ level=folder_node.level + 1,
+ item_type="folder",
+ created=datetime.fromtimestamp(stat.st_ctime, tz=timezone.utc),
+ modified=datetime.fromtimestamp(stat.st_mtime, tz=timezone.utc),
+ parent=folder_node,
+ items=None,
+ rel_path=os.path.join(folder_node.rel_path, entry.name),
+ )
+ )
+ for entry in files:
+ stat = entry.stat(follow_symlinks=False)
+ hidden_entries.append(
+ _TreeEntry(
+ name=entry.name,
+ level=folder_node.level + 1,
+ item_type="file",
+ created=datetime.fromtimestamp(stat.st_ctime, tz=timezone.utc),
+ modified=datetime.fromtimestamp(stat.st_mtime, tz=timezone.utc),
+ parent=folder_node,
+ items=None,
+ rel_path=os.path.join(folder_node.rel_path, entry.name),
+ )
+ )
+
+ if not hidden_entries:
+ return None
+
+ return _create_global_limit_comment(folder_node, hidden_entries)
def _prune_to_visible(node: _TreeEntry, visible_ids: set[int]) -> None:
@@ -339,7 +439,7 @@ def _prune_to_visible(node: _TreeEntry, visible_ids: set[int]) -> None:
if not visible_ids or id(child) in visible_ids:
_prune_to_visible(child, visible_ids)
filtered.append(child)
- node.items = filtered
+ node.items = filtered or None
def _mark_last_flags(node: _TreeEntry) -> None:
@@ -483,10 +583,6 @@ def _apply_sorting_and_limits(
if not overflow:
return
- if len(overflow) == 1 and limit > 0:
- combined.append(overflow[0])
- return
-
combined.append(
_create_summary_comment(
directory_node,
diff --git a/tests/test_file_tree_visualize.py b/tests/test_file_tree_visualize.py
index ae2684b7e..834c8d17e 100644
--- a/tests/test_file_tree_visualize.py
+++ b/tests/test_file_tree_visualize.py
@@ -464,6 +464,7 @@ def build_scenarios() -> List[Scenario]:
{
"output_mode": OUTPUT_MODE_NESTED,
"max_lines": 6,
+ "folders_first": True,
"sort": (SORT_BY_NAME, SORT_ASC),
},
),
@@ -643,6 +644,180 @@ def build_scenarios() -> List[Scenario]:
)
)
+ stress_structure = {
+ "level1_a": {
+ "level2_a1": {
+ "leaf_a1_1.txt": "",
+ "leaf_a1_2.txt": "",
+ "leaf_a1_3.txt": "",
+ },
+ "level2_a2": {
+ "leaf_a2_1.txt": "",
+ "leaf_a2_2.txt": "",
+ "leaf_a2_3.txt": "",
+ },
+ "level2_a3": {
+ "subfolder_a3": {
+ "deep_a3_1.txt": "",
+ "deep_a3_2.txt": "",
+ "deep_a3_3.txt": "",
+ "subsubfolder_a3": {
+ "deep_a3_4.txt": "",
+ "deep_a3_5.txt": "",
+ },
+ "subsubfolder_a3_extra": {
+ "deep_a3_extra_1.txt": "",
+ "deep_a3_extra_2.txt": "",
+ },
+ },
+ "subfolder_a3_extra": {
+ "deep_extra_1.txt": "",
+ "deep_extra_2.txt": "",
+ },
+ "subfolder_a3_more": {
+ "deep_more_1.txt": "",
+ },
+ },
+ },
+ "level1_b": {
+ "level2_b1": {
+ "leaf_b1_1.txt": "",
+ "leaf_b1_2.txt": "",
+ },
+ "level2_b2": {
+ "leaf_b2_1.txt": "",
+ "leaf_b2_2.txt": "",
+ "leaf_b2_3.txt": "",
+ "leaf_b2_4.txt": "",
+ "leaf_b2_5.txt": "",
+ },
+ "level2_b3": {
+ "subfolder_b3": {
+ "deep_b3_1.txt": "",
+ "deep_b3_2.txt": "",
+ "deep_b3_3.txt": "",
+ "deep_b3_4.txt": "",
+ },
+ "subfolder_b3_extra": {
+ "deeper_b3_extra.txt": "",
+ "deeper_b3_extra_2.txt": "",
+ },
+ },
+ },
+ "level1_c": {
+ "level2_c1": {
+ "leaf_c1_1.txt": "",
+ "leaf_c1_2.txt": "",
+ "leaf_c1_3.txt": "",
+ "leaf_c1_4.txt": "",
+ "leaf_c1_5.txt": "",
+ },
+ "level2_c2": {
+ "subfolder_c2": {
+ "deep_c2_1.txt": "",
+ "deep_c2_2.txt": "",
+ },
+ "subfolder_c2_extra": {
+ "deep_c2_extra_1.txt": "",
+ },
+ },
+ },
+ "level1_d": {
+ "level2_d1": {
+ "leaf_d1_1.txt": "",
+ "leaf_d1_2.txt": "",
+ "leaf_d1_3.txt": "",
+ },
+ "level2_d2": {
+ "subfolder_d2": {
+ "deep_d2_1.txt": "",
+ "deep_d2_2.txt": "",
+ },
+ },
+ },
+ "root_file.txt": "",
+ "root_notes.md": "",
+ "root_file_2.txt": "",
+ "root_file_3.txt": "",
+ }
+
+ scenarios.append(
+ Scenario(
+ name="mixed_limits_baseline",
+ description="Full structure without truncation for comparison",
+ structure=stress_structure,
+ configs=[
+ Config(
+ "string • no limits baseline",
+ {
+ "output_mode": OUTPUT_MODE_STRING,
+ "folders_first": True,
+ "sort": (SORT_BY_NAME, SORT_ASC),
+ },
+ ),
+ Config(
+ "flat • no limits baseline",
+ {
+ "output_mode": OUTPUT_MODE_FLAT,
+ "folders_first": True,
+ "sort": (SORT_BY_NAME, SORT_ASC),
+ },
+ ),
+ Config(
+ "nested • no limits baseline",
+ {
+ "output_mode": OUTPUT_MODE_NESTED,
+ "folders_first": True,
+ "sort": (SORT_BY_NAME, SORT_ASC),
+ },
+ ),
+ ],
+ )
+ )
+
+ scenarios.append(
+ Scenario(
+ name="mixed_limits_stress",
+ description="Same structure with local and global limits applied",
+ structure=stress_structure,
+ configs=[
+ Config(
+ "string • mixed local/global limits stress",
+ {
+ "output_mode": OUTPUT_MODE_STRING,
+ "folders_first": True,
+ "sort": (SORT_BY_NAME, SORT_ASC),
+ "max_folders": 2,
+ "max_files": 2,
+ "max_lines": 19,
+ },
+ ),
+ Config(
+ "flat • mixed limits stress",
+ {
+ "output_mode": OUTPUT_MODE_FLAT,
+ "folders_first": True,
+ "sort": (SORT_BY_NAME, SORT_ASC),
+ "max_folders": 2,
+ "max_files": 2,
+ "max_lines": 19,
+ },
+ ),
+ Config(
+ "nested • mixed limits stress",
+ {
+ "output_mode": OUTPUT_MODE_NESTED,
+ "folders_first": True,
+ "sort": (SORT_BY_NAME, SORT_ASC),
+ "max_folders": 2,
+ "max_files": 2,
+ "max_lines": 19,
+ },
+ ),
+ ],
+ )
+ )
+
return scenarios