`5943c43`

Fix external path globbing

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 3 weeks ago

SHA: 5943c43d96ef6e8cc09127b6af69f6c6bedaf5b7
Parents: d68665f
Tree: 882279e

3 changed files

Status	File	+	-
M	`src/loader/runtime/prompting.py`	4	0
M	`src/loader/tools/file_tools.py`	54	7
M	`tests/test_tools.py`	18	0

src/loader/runtime/prompting.pymodified

  - For servers, watchers, preview commands, or anything else that keeps running,
    call `bash` with `background=true`, then inspect it with `bash_wait` or
    `bash_jobs` instead of blocking the turn in the foreground
 +- If the task names an external directory like `~/Loader/...`, keep operating on
 +  that exact path instead of falling back to the repo cwd; file tools accept
 +  absolute and `~` paths, and `glob` works best with `path="~/Loader/..."`
 +  plus a relative `pattern` like `*.html`
  - Concise reporting is fine, and numbered lists are allowed when they
    communicate plan or evidence clearly
  """,

src/loader/tools/file_tools.pymodified

      resolve_workspace_path,
+ )
 +_GLOB_MAGIC_CHARS = "*?["
++
++
 +def _has_glob_magic(segment: str) -> bool:
 +    """Return whether one path segment contains glob syntax."""
++
 +    return any(char in segment for char in _GLOB_MAGIC_CHARS)
++
++
 +def _resolve_glob_base_and_pattern(
 +    pattern: str,
 +    path: str,
 +) -> tuple[Path, str]:
 +    """Resolve glob inputs, including `~`/absolute patterns outside the cwd."""
++
 +    expanded_pattern = Path(pattern).expanduser()
 +    pattern_is_explicit_path = pattern.startswith("~") or expanded_pattern.is_absolute()
++
 +    if not pattern_is_explicit_path:
 +        base_path = resolve_workspace_path(path, workspace_root=None)
 +        return base_path, pattern
++
 +    base_parts: list[str] = []
 +    pattern_parts: list[str] = []
 +    saw_glob = False
 +    for part in expanded_pattern.parts:
 +        if saw_glob or _has_glob_magic(part):
 +            saw_glob = True
 +            pattern_parts.append(part)
 +        else:
 +            base_parts.append(part)
++
 +    if not pattern_parts:
 +        if expanded_pattern.name:
 +            pattern_parts = [expanded_pattern.name]
 +            base_parts = list(expanded_pattern.parent.parts)
 +        else:
 +            pattern_parts = ["*"]
++
 +    raw_base = str(Path(*base_parts)) if base_parts else expanded_pattern.anchor or "."
 +    base_path = resolve_workspace_path(raw_base, workspace_root=None)
 +    return base_path, "/".join(pattern_parts)
++
  class ReadTool(Tool):
      """Read file contents."""
      @property
      def description(self) -> str:
 -        return "Find files matching a glob pattern (e.g., '**/*.py', 'src/*.ts')."
 +        return (
 +            "Find files matching a glob pattern (e.g., '**/*.py', 'src/*.ts'). "
 +            "For external directories, prefer path='~/Loader/animals' with "
 +            "pattern='*.html'; absolute or '~'-prefixed patterns are also accepted."
 +        )
      @property
      def parameters(self) -> dict[str, Any]:
      ) -> ToolResult:
          try:
              # Glob is read-only — don't enforce workspace boundary
 -            base_path = resolve_workspace_path(
 -                path,
 -                workspace_root=None,
 -            )
 +            base_path, effective_pattern = _resolve_glob_base_and_pattern(pattern, path)
          except FileNotFoundError:
              return ToolResult(f"Directory not found: {path}", is_error=True)
          except Exception as exc:
              return ToolResult(f"Error resolving directory: {exc}", is_error=True)
          if not base_path.exists():
 -            return ToolResult(f"Directory not found: {path}", is_error=True)
 +            missing_target = path if path != "." else str(base_path)
 +            return ToolResult(f"Directory not found: {missing_target}", is_error=True)
          try:
 -            matches = list(base_path.glob(pattern))
 +            matches = list(base_path.glob(effective_pattern))
              # Sort by modification time (newest first)
              matches.sort(key=lambda p: p.stat().st_mtime, reverse=True)
                  output,
                  metadata={
                      "base_path": str(base_path),
 +                    "effective_pattern": effective_pattern,
 +                    "requested_pattern": pattern,
                      "num_files": len(matches),
                      "truncated": truncated if "truncated" in locals() else False,
                  },

tests/test_tools.pymodified

          assert not result.is_error
          assert "No files matching" in result.output
 +    @pytest.mark.asyncio
 +    async def test_glob_expands_home_prefixed_pattern(self, tool, monkeypatch, temp_dir):
 +        home_dir = temp_dir / "fake-home"
 +        animals_dir = home_dir / "Loader" / "animals"
 +        animals_dir.mkdir(parents=True)
 +        (animals_dir / "penguins.html").write_text("<h1>Penguins</h1>\n")
 +        (animals_dir / "wolves.html").write_text("<h1>Wolves</h1>\n")
++
 +        monkeypatch.setenv("HOME", str(home_dir))
++
 +        result = await tool.execute(pattern="~/Loader/animals/*.html")
++
 +        assert not result.is_error
 +        assert "penguins.html" in result.output
 +        assert "wolves.html" in result.output
 +        assert result.metadata["base_path"] == str(animals_dir.resolve())
 +        assert result.metadata["effective_pattern"] == "*.html"
++
  class TestBashTool:
      """Tests for BashTool."""