skillflow-py 1.3.2__tar.gz → 1.4.0__tar.gz

{skillflow_py-1.3.2 → skillflow_py-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: skillflow-py
-Version: 1.3.2
+Version: 1.4.0
 Summary: Config-agnostic LLM pipeline graph executor — turn skills into flows
 Author: Skillflow contributors
 License-Expression: MIT

{skillflow_py-1.3.2 → skillflow_py-1.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "skillflow-py"
-version = "1.3.2"
+version = "1.4.0"
 description = "Config-agnostic LLM pipeline graph executor — turn skills into flows"
 readme = "README.md"
 license = "MIT"

{skillflow_py-1.3.2 → skillflow_py-1.4.0}/src/skillflow/read_tools.py

@@ -27,6 +27,21 @@ from pathlib import Path
 # the ``truncated`` flag signals when there is more to page through.
 _MAX_READ_LINES = 2000
 
+# Directories never worth enumerating/searching as "source" — VCS internals and
+# build/dependency caches. Mirrors dir_tree/list_tree's BLOCKED set, which the
+# generated directory read tools previously lacked: a single list_repo_root on a
+# real repo dumped the whole .git tree (~64% of files) into the agent's context.
+_BLOCKED_DIR_PARTS = {".git", "__pycache__", ".venv", "node_modules",
+                      ".mypy_cache", ".pytest_cache", ".ruff_cache"}
+# Hard cap on entries returned by a directory listing so one call can't flood
+# the context with thousands of paths.
+_MAX_LIST_ENTRIES = 1000
+
+
+def _is_blocked_path(rel) -> bool:
+    """True if any path component is a blocked VCS/build directory."""
+    return any(part in _BLOCKED_DIR_PARTS for part in Path(rel).parts)
+
 
 def _page_lines(text: str, start_line: int = 0, end_line: int | None = None) -> dict:
     """Slice file text into a line-numbered window with paging metadata.
@@ -407,19 +422,25 @@ def make_read_tool_fns(specs: list[dict], workspace_root: str,
 
             def _list_dir(_paths=dir_paths) -> str:
                 entries = []
+                truncated = False
                 for dp in _paths:
                     d = Path(dp)
                     if not d.is_dir():
                         continue
                     for f in sorted(d.rglob("*")):
-                        if f.is_file() and f.name != ".gitkeep":
-                            rel = f.relative_to(d)
-                            st = f.stat()
-                            entries.append({
-                                "name": str(rel),
-                                "size": st.st_size,
-                            })
-                return json.dumps(entries, ensure_ascii=False)
+                        if not (f.is_file() and f.name != ".gitkeep"):
+                            continue
+                        rel = f.relative_to(d)
+                        if _is_blocked_path(rel):
+                            continue  # skip .git / build / dependency caches
+                        entries.append({"name": str(rel), "size": f.stat().st_size})
+                        if len(entries) >= _MAX_LIST_ENTRIES:
+                            truncated = True
+                            break
+                    if truncated:
+                        break
+                return json.dumps({"files": entries, "truncated": truncated},
+                                  ensure_ascii=False)
 
             def _read_dir_file(name: str, start_line: int = 0,
                                end_line: int | None = None, _paths=dir_paths) -> dict:
@@ -465,6 +486,8 @@ def make_read_tool_fns(specs: list[dict], workspace_root: str,
                     for f in sorted(d.rglob(glob) if glob else d.rglob("*")):
                         if not f.is_file() or f.name == ".gitkeep":
                             continue
+                        if _is_blocked_path(f.relative_to(d)):
+                            continue  # skip .git / build / dependency caches
                         # Skip binary-looking files
                         if f.suffix in (".pyc", ".pyo", ".so", ".o", ".bin"):
                             continue

{skillflow_py-1.3.2 → skillflow_py-1.4.0}/src/skillflow/tools/repo_apply/impl.py

@@ -1,39 +1,31 @@
 """Apply files from draft directory to project repo."""
 
+import fnmatch
 import shutil
 import subprocess
-import sys
 from pathlib import Path
 
 
-def _probe(msg: str) -> None:
-    """Diagnostic log for the step-dir-contains-whole-repo investigation.
-
-    Prints to stderr with a greppable marker so it shows in `docker logs`.
-    """
-    print(f"[repo_apply.probe] {msg}", file=sys.stderr, flush=True)
-
-
 def repo_apply(source_dir: str, *, workspace_root: str = "",
                project_root: str = "",
                step_id: str = "", project_id: str = "",
-               task_name: str = "") -> dict:
+               task_name: str = "", ignore=None) -> dict:
     src = Path(source_dir)
     if not src.is_absolute():
         src = Path(workspace_root) / source_dir
     src = src.resolve()
     dst = Path(project_root).resolve()
 
-    # PROBE: what is repo_apply actually reading from, and is it the repo itself?
-    _probe(f"step={step_id} project={project_id} task={task_name!r} "
-           f"source_dir_param={source_dir!r} resolved_src={src} "
-           f"project_root={dst} workspace_root={workspace_root!r} "
-           f"src==dst? {src == dst}")
-
     if not src.exists():
         return {"applied": False, "files": [],
                 "error": f"Source dir not found: {source_dir}"}
 
+    # Caller-supplied ignore globs (fnmatch), matched against BOTH the path
+    # relative to source_dir AND the basename — so "web/js/_x.json" and "_x.json"
+    # style patterns both work. Lets a host keep control/scratch files (e.g. a
+    # deletions manifest) in the step dir without them landing in the repo.
+    ignore_globs = tuple(ignore or ())
+
     applied_files = []
     for f in sorted(src.rglob("*")):
         if not f.is_file():
@@ -43,22 +35,21 @@ def repo_apply(source_dir: str, *, workspace_root: str = "",
         if ".git/" in str(f):
             continue
         rel = f.relative_to(src)
+        if ignore_globs and any(
+            fnmatch.fnmatch(str(rel), pat) or fnmatch.fnmatch(f.name, pat)
+            for pat in ignore_globs
+        ):
+            continue
         target = dst / rel
         target.parent.mkdir(parents=True, exist_ok=True)
         shutil.copy2(f, target)
         applied_files.append(str(rel))
 
-    # PROBE: how many files did we just apply? A handful = normal surgical edit;
-    # dozens/hundreds = the leak. Dump a sample so we can see WHAT leaked.
-    if len(applied_files) > 15:
-        _probe(f"LARGE APPLY step={step_id}: {len(applied_files)} files from "
-               f"{src} — first 15: {applied_files[:15]}")
-    else:
-        _probe(f"step={step_id}: applied {len(applied_files)} file(s): {applied_files}")
-
     if not applied_files:
-        return {"applied": False, "files": [],
-                "error": "No files to apply (empty or all filtered)"}
+        # Empty source = a legitimate no-op step (the agent determined no change
+        # was needed and produced no output). Nothing to copy or commit; report
+        # success so the on_deliver hook doesn't retry/fail a clean no-op.
+        return {"applied": True, "files": [], "committed": False}
 
     # git add + commit
     r = subprocess.run(["git", "add", "-A"], cwd=dst,

{skillflow_py-1.3.2 → skillflow_py-1.4.0}/src/skillflow/tools/repo_apply/tool.yaml

@@ -8,3 +8,7 @@ parameters:
     type: string
     description: "Source directory path (absolute or relative to workspace)"
     required: true
+  ignore:
+    type: array
+    description: "Optional list of fnmatch globs (matched against the path relative to source_dir and the basename). Matching files are NOT copied to the repo — use for host control/scratch files kept in the step dir (e.g. a deletions manifest)."
+    required: false

{skillflow_py-1.3.2 → skillflow_py-1.4.0}/src/skillflow_py.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: skillflow-py
-Version: 1.3.2
+Version: 1.4.0
 Summary: Config-agnostic LLM pipeline graph executor — turn skills into flows
 Author: Skillflow contributors
 License-Expression: MIT

{skillflow_py-1.3.2 → skillflow_py-1.4.0}/src/skillflow_py.egg-info/SOURCES.txt

@@ -76,6 +76,7 @@ tests/test_graph.py
 tests/test_integration.py
 tests/test_integration_configs.py
 tests/test_migration_regression.py
+tests/test_noop_floor_fix.py
 tests/test_notifications.py
 tests/test_outbox.py
 tests/test_read_tools_exec.py

skillflow_py-1.4.0/tests/test_noop_floor_fix.py

@@ -0,0 +1,65 @@
+"""Regression tests for the existing-repo "no-op floor" data-corruption bug.
+
+Two skillflow-side guarantees the host (AItelier) relies on after the fix:
+
+1. ``repo_apply`` on an EMPTY source dir is a no-op SUCCESS, not an error.
+   A legitimate "no change needed" step promotes empty staging; on_deliver
+   must not retry/fail it.
+
+2. The generated directory read tools (``list_<label>`` / ``search_<label>``)
+   exclude ``.git`` and build/dependency caches and cap their output, so a
+   single ``list_repo_root`` can't dump the whole ``.git`` tree (tens of
+   thousands of tokens) into the agent's context.
+"""
+
+import json
+import subprocess
+from pathlib import Path
+
+from skillflow.read_tools import _is_blocked_path, make_read_tool_fns
+from skillflow.tool_loader import ToolLoader
+
+_REAL_TOOLS = Path(__file__).parent.parent / "src" / "skillflow" / "tools"
+
+
+def test_repo_apply_empty_source_is_noop_success(tmp_path):
+    repo = tmp_path / "repo"
+    repo.mkdir()
+    subprocess.run(["git", "init", "-q"], cwd=repo, check=True)
+
+    src = tmp_path / "empty_staging"
+    src.mkdir()  # no files
+
+    repo_apply = ToolLoader(_REAL_TOOLS).load_fn("repo_apply")
+    res = repo_apply(str(src), project_root=str(repo))
+
+    assert res["applied"] is True
+    assert res["files"] == []
+    assert res.get("committed") is False
+    assert "error" not in res
+
+
+def test_is_blocked_path_excludes_vcs_and_build_dirs():
+    assert _is_blocked_path(Path(".git/objects/ab/cd"))
+    assert _is_blocked_path("node_modules/foo/bar.js")
+    assert _is_blocked_path("pkg/__pycache__/x.pyc")
+    assert not _is_blocked_path("src/main.py")
+    assert not _is_blocked_path("docs/readme.md")
+
+
+def test_list_repo_tool_excludes_git_tree(tmp_path):
+    repo = tmp_path / "repo"
+    (repo / ".git" / "objects").mkdir(parents=True)
+    (repo / ".git" / "objects" / "deadbeef").write_text("binblob")
+    (repo / "src").mkdir()
+    (repo / "src" / "main.py").write_text("x = 1\n")
+
+    specs = [{"source_type": "repository", "mode": "tool"}]
+    fns = make_read_tool_fns(specs, str(tmp_path), code_root=str(repo))
+
+    list_fn = next(fn for name, fn in fns.items() if name.startswith("list_"))
+    payload = json.loads(list_fn())
+    names = [e["name"] for e in payload["files"]]
+
+    assert "src/main.py" in names
+    assert not any(".git" in n for n in names), names

{skillflow_py-1.3.2 → skillflow_py-1.4.0}/tests/test_tools.py

@@ -144,7 +144,67 @@ class TestRepoApply:
         result = repo_apply(source_dir=str(empty),
                             workspace_root=str(tmp_path),
                             project_root=str(proj))
-        assert result["applied"] is False
+        # Empty source is a legitimate no-op step (agent determined no change
+        # needed): report success with no files, not an error that would make
+        # the on_deliver hook retry/fail a clean no-op.
+        assert result["applied"] is True
+        assert result["files"] == []
+        assert result.get("committed") is False
+
+    def test_ignore_globs_not_copied(self, tmp_path):
+        """Files matching an `ignore` glob stay out of the repo (host control
+        files kept in the step dir, e.g. a deletions manifest)."""
+        proj = tmp_path / "project"
+        proj.mkdir()
+        subprocess.run(["git", "init", "-b", "main"], cwd=proj,
+                       capture_output=True)
+        subprocess.run(["git", "config", "user.email", "test@test.com"],
+                       cwd=proj, capture_output=True)
+        subprocess.run(["git", "config", "user.name", "Test"], cwd=proj,
+                       capture_output=True)
+        (proj / ".gitkeep").write_text("")
+        subprocess.run(["git", "add", "."], cwd=proj, capture_output=True)
+        subprocess.run(["git", "commit", "-m", "init"], cwd=proj,
+                       capture_output=True)
+
+        draft = tmp_path / "draft"
+        draft.mkdir()
+        (draft / "keep.py").write_text("x = 1\n")
+        (draft / "_deletions.json").write_text('["old.js"]')
+        (draft / "sub").mkdir()
+        (draft / "sub" / "_deletions.json").write_text('["y"]')
+
+        result = repo_apply(source_dir=str(draft),
+                            workspace_root=str(tmp_path),
+                            project_root=str(proj),
+                            ignore=["_deletions.json"])
+
+        assert result["applied"] is True
+        assert "keep.py" in result["files"]
+        # basename-matched at any depth → never copied, never committed
+        assert "_deletions.json" not in result["files"]
+        assert "sub/_deletions.json" not in result["files"]
+        assert (proj / "keep.py").exists()
+        assert not (proj / "_deletions.json").exists()
+        assert not (proj / "sub" / "_deletions.json").exists()
+
+    def test_ignore_default_none_copies_everything(self, tmp_path):
+        """Backward-compat: no `ignore` arg → every file copied (unchanged)."""
+        proj = tmp_path / "project"
+        proj.mkdir()
+        subprocess.run(["git", "init", "-b", "main"], cwd=proj,
+                       capture_output=True)
+        subprocess.run(["git", "config", "user.email", "t@t"], cwd=proj,
+                       capture_output=True)
+        subprocess.run(["git", "config", "user.name", "T"], cwd=proj,
+                       capture_output=True)
+        draft = tmp_path / "draft"
+        draft.mkdir()
+        (draft / "_deletions.json").write_text("[]")
+        result = repo_apply(source_dir=str(draft),
+                            workspace_root=str(tmp_path),
+                            project_root=str(proj))
+        assert "_deletions.json" in result["files"]
 
 
 class TestLint: