Add deepagents_rl package sources

src/deepagents_rl/train/swe_env.py

@@ -44,6 +44,22 @@ def _result_to_str(obj: Any) -> str:
         return obj[:8000]
     if hasattr(obj, "output") and isinstance(obj.output, str):
         return obj.output[:8000]
+    # Prefer listing entries before error (LsResult / GlobResult)
+    entries = getattr(obj, "entries", None)
+    if entries is not None:
+        lines: list[str] = []
+        for e in entries:
+            if isinstance(e, dict):
+                lines.append(str(e.get("path") or e))
+            else:
+                lines.append(str(e))
+        return ("\n".join(lines) if lines else "(empty directory)")[:8000]
+    matches = getattr(obj, "matches", None)
+    if matches is not None and not getattr(obj, "error", None):
+        try:
+            return json.dumps(matches, default=str)[:8000]
+        except Exception:
+            return str(matches)[:8000]
     if hasattr(obj, "error") and obj.error:
         return f"ERROR: {obj.error}"[:8000]
     try:
@@ -52,6 +68,21 @@ def _result_to_str(obj: Any) -> str:
         return str(obj)[:8000]
 
 
+# Common dirs Qwen invents that most SWE-bench repos do not have.
+_PHANTOM_DIRS = frozenset(
+    {
+        "src",
+        "lib",
+        "app",
+        "source",
+        "sources",
+        "code",
+        "project",
+        "workspace",
+    }
+)
+
+
 def _as_str_list(val: Any) -> list[str]:
     if val is None:
         return []
@@ -412,14 +443,27 @@ class DeepAgentSWEEnv:
 
     @staticmethod
     def _norm_path(path: str | None) -> str:
-        p = (path or ".").strip()
-        if p in ("", "/", "./", ".\\"):
+        p = (path or ".").strip().strip("'\"")
+        if p in ("", "/", "./", ".\\", "~"):
             return "."
         # virtual_mode often wants leading slash for absolute-in-sandbox paths
         if p.startswith("./"):
             p = p[2:]
+        if p.startswith("/"):
+            p = p.lstrip("/") or "."
+        # Drop trailing slash for alias matching
+        p = p.rstrip("/") or "."
         return p or "."
 
+    @classmethod
+    def _resolve_ls_path(cls, path: str | None) -> tuple[str, str | None]:
+        """Map invented dirs (src/lib/…) to repo root before hitting the backend."""
+        p = cls._norm_path(path)
+        head = p.split("/", 1)[0].lower()
+        if head in _PHANTOM_DIRS:
+            return ".", p
+        return p, None
+
     def _is_missing(self, result_obj: Any, text: str) -> bool:
         err = getattr(result_obj, "error", None)
         if err and "path_not_found" in str(err).lower():
@@ -428,7 +472,13 @@ class DeepAgentSWEEnv:
 
     def _root_listing(self) -> str:
         backend = self._require_backend()
-        return _result_to_str(backend.ls("."))
+        # Prefer "/" then "." for virtual_mode backends
+        for candidate in ("/", "."):
+            result = backend.ls(candidate)
+            out = _result_to_str(result)
+            if not self._is_missing(result, out):
+                return out
+        return "(unable to list repo root)"
 
     @_traced_tool
     def ls(self, path: str = ".") -> str:
@@ -442,15 +492,20 @@ class DeepAgentSWEEnv:
             Directory listing as text (falls back to repo root if path missing).
         """
         backend = self._require_backend()
-        path = self._norm_path(path)
+        path, aliased_from = self._resolve_ls_path(path)
         result = backend.ls(path)
         out = _result_to_str(result)
         if self._is_missing(result, out):
             root = self._root_listing()
+            _vlog("tool.ls.fallback_root", requested=aliased_from or path)
+            return (
+                f"Path '{aliased_from or path}' does not exist here.\n"
+                f"Listing repo root instead (use these real paths):\n{root}"
+            )
+        if aliased_from and aliased_from != path:
+            _vlog("tool.ls.alias", requested=aliased_from, used=path)
             return (
-                f"Path '{path}' was not found in this repo sandbox.\n"
-                f"Tip: there is often no 'src/' directory. Start with path='.' (repo root).\n"
-                f"Repo root listing:\n{root}"
+                f"Note: '{aliased_from}' is not used in this repo; showing repo root:\n{out}"
             )
         return out
 
@@ -466,14 +521,13 @@ class DeepAgentSWEEnv:
             Matching paths as text.
         """
         backend = self._require_backend()
-        path = self._norm_path(path)
+        path, aliased_from = self._resolve_ls_path(path)
         result = backend.glob(pattern, path)
         out = _result_to_str(result)
         if self._is_missing(result, out):
-            root = self._root_listing()
             return (
-                f"Path '{path}' not found for glob. Retry with path='.'.\n"
-                f"Repo root listing:\n{root}"
+                f"Path '{aliased_from or path}' not found for glob; retrying at repo root.\n"
+                f"{_result_to_str(backend.glob(pattern, '.'))}"
             )
         return out
 
@@ -489,13 +543,13 @@ class DeepAgentSWEEnv:
             Matching lines as text.
         """
         backend = self._require_backend()
-        path = self._norm_path(path)
+        path, aliased_from = self._resolve_ls_path(path)
         result = backend.grep(pattern, path)
         out = _result_to_str(result)
         if self._is_missing(result, out):
             return (
-                f"Path '{path}' not found for grep. Retry with path='.' (repo root).\n"
-                f"Repo root listing:\n{self._root_listing()}"
+                f"Path '{aliased_from or path}' not found for grep; retrying at repo root.\n"
+                f"{_result_to_str(backend.grep(pattern, '.'))}"
             )
         return out
 
@@ -513,14 +567,24 @@ class DeepAgentSWEEnv:
         """
         backend = self._require_backend()
         file_path = self._norm_path(file_path)
-        result = backend.read(file_path, offset=offset, limit=limit)
-        out = _result_to_str(result)
-        if self._is_missing(result, out):
-            return (
-                f"File '{file_path}' not found. Use ls path='.' or glob to discover real paths.\n"
-                f"Repo root listing:\n{self._root_listing()}"
-            )
-        return out
+        # If model invents src/foo.py, try stripping the phantom prefix once.
+        head = file_path.split("/", 1)[0].lower()
+        candidates = [file_path]
+        if head in _PHANTOM_DIRS and "/" in file_path:
+            candidates.append(file_path.split("/", 1)[1])
+        last_out = ""
+        for cand in candidates:
+            result = backend.read(cand, offset=offset, limit=limit)
+            out = _result_to_str(result)
+            last_out = out
+            if not self._is_missing(result, out):
+                if cand != file_path:
+                    return f"(read via '{cand}' — '{file_path}' missing)\n{out}"
+                return out
+        return (
+            f"File '{file_path}' not found. Use ls path='.' or glob to discover real paths.\n"
+            f"Repo root listing:\n{self._root_listing()}\nLast error: {last_out}"
+        )
 
     @_traced_tool
     def write_file(self, file_path: str, content: str) -> str: