Merge pull request #19 from huggingface/feat/hf-repo-tools

.gitignore

@@ -16,4 +16,5 @@ wheels/
 /logs
 hf-agent-leaderboard/
 .cursor/
-session_logs/skills/
+session_logs/
+skills/

agent/core/agent_loop.py

@@ -76,7 +76,19 @@ def _needs_approval(tool_name: str, tool_args: dict, config: Config | None = Non
         # Other operations (create_repo, etc.) always require approval
         if operation in ["create_repo"]:
             return True
-    
+
+    # hf_repo_files: upload (can overwrite) and delete require approval
+    if tool_name == "hf_repo_files":
+        operation = tool_args.get("operation", "")
+        if operation in ["upload", "delete"]:
+            return True
+
+    # hf_repo_git: destructive operations require approval
+    if tool_name == "hf_repo_git":
+        operation = tool_args.get("operation", "")
+        if operation in ["delete_branch", "delete_tag", "merge_pr", "create_repo", "update_repo"]:
+            return True
+
     return False
 
 

agent/core/tools.py

@@ -37,13 +37,20 @@ from agent.tools.github_read_file import (
 )
 from agent.tools.jobs_tool import HF_JOBS_TOOL_SPEC, hf_jobs_handler
 from agent.tools.plan_tool import PLAN_TOOL_SPEC, plan_tool_handler
-from agent.tools.private_hf_repo_tools import (
-    PRIVATE_HF_REPO_TOOL_SPEC,
-    private_hf_repo_handler,
+from agent.tools.hf_repo_files_tool import (
+    HF_REPO_FILES_TOOL_SPEC,
+    hf_repo_files_handler,
+)
+from agent.tools.hf_repo_git_tool import (
+    HF_REPO_GIT_TOOL_SPEC,
+    hf_repo_git_handler,
 )
 
-# NOTE: Utils tool disabled - date/time now loaded into system prompt at initialization
-# from agent.tools.utils_tools import UTILS_TOOL_SPEC, utils_handler
+# NOTE: Private HF repo tool disabled - replaced by hf_repo_files and hf_repo_git
+# from agent.tools.private_hf_repo_tools import (
+#     PRIVATE_HF_REPO_TOOL_SPEC,
+#     private_hf_repo_handler,
+# )
 
 # Suppress aiohttp deprecation warning
 warnings.filterwarnings(
@@ -281,20 +288,21 @@ def create_builtin_tools() -> list[ToolSpec]:
             parameters=HF_JOBS_TOOL_SPEC["parameters"],
             handler=hf_jobs_handler,
         ),
+        # HF Repo management tools
         ToolSpec(
-            name=PRIVATE_HF_REPO_TOOL_SPEC["name"],
-            description=PRIVATE_HF_REPO_TOOL_SPEC["description"],
-            parameters=PRIVATE_HF_REPO_TOOL_SPEC["parameters"],
-            handler=private_hf_repo_handler,
+            name=HF_REPO_FILES_TOOL_SPEC["name"],
+            description=HF_REPO_FILES_TOOL_SPEC["description"],
+            parameters=HF_REPO_FILES_TOOL_SPEC["parameters"],
+            handler=hf_repo_files_handler,
         ),
-        # NOTE: Utils tool disabled - date/time now loaded into system prompt at initialization (less tool calls=more reliablity)
-        # ToolSpec(
-        #     name=UTILS_TOOL_SPEC["name"],
-        #     description=UTILS_TOOL_SPEC["description"],
-        #     parameters=UTILS_TOOL_SPEC["parameters"],
-        #     handler=utils_handler,
-        # ),
-        # GitHub tools
+        ToolSpec(
+            name=HF_REPO_GIT_TOOL_SPEC["name"],
+            description=HF_REPO_GIT_TOOL_SPEC["description"],
+            parameters=HF_REPO_GIT_TOOL_SPEC["parameters"],
+            handler=hf_repo_git_handler,
+        ),
+
+
         # NOTE: Github search code tool disabled - a bit buggy
         # ToolSpec(
         #     name=GITHUB_SEARCH_CODE_TOOL_SPEC["name"],

agent/main.py

@@ -287,6 +287,95 @@ async def event_listener(
                                     if len(all_lines) > 5:
                                         print("...")
 
+                    elif tool_name == "hf_repo_files":
+                        # Handle repo files operations (upload, delete)
+                        repo_id = arguments.get("repo_id", "")
+                        repo_type = arguments.get("repo_type", "model")
+                        revision = arguments.get("revision", "main")
+
+                        # Build repo URL
+                        if repo_type == "model":
+                            repo_url = f"https://huggingface.co/{repo_id}"
+                        else:
+                            repo_url = f"https://huggingface.co/{repo_type}s/{repo_id}"
+
+                        print(f"Repository: {repo_id}")
+                        print(f"Type: {repo_type}")
+                        print(f"Branch: {revision}")
+                        print(f"URL: {repo_url}")
+
+                        if operation == "upload":
+                            path = arguments.get("path", "")
+                            content = arguments.get("content", "")
+                            create_pr = arguments.get("create_pr", False)
+
+                            print(f"File: {path}")
+                            if create_pr:
+                                print("Mode: Create PR")
+
+                            if isinstance(content, str):
+                                all_lines = content.split("\n")
+                                line_count = len(all_lines)
+                                size_bytes = len(content.encode("utf-8"))
+                                size_kb = size_bytes / 1024
+
+                                print(f"Lines: {line_count}")
+                                if size_kb < 1024:
+                                    print(f"Size: {size_kb:.2f} KB")
+                                else:
+                                    print(f"Size: {size_kb / 1024:.2f} MB")
+
+                                # Show full content
+                                print(f"Content:\n{content}")
+
+                        elif operation == "delete":
+                            patterns = arguments.get("patterns", [])
+                            if isinstance(patterns, str):
+                                patterns = [patterns]
+                            print(f"Patterns to delete: {', '.join(patterns)}")
+
+                    elif tool_name == "hf_repo_git":
+                        # Handle git operations (branches, tags, PRs, repo management)
+                        repo_id = arguments.get("repo_id", "")
+                        repo_type = arguments.get("repo_type", "model")
+
+                        # Build repo URL
+                        if repo_type == "model":
+                            repo_url = f"https://huggingface.co/{repo_id}"
+                        else:
+                            repo_url = f"https://huggingface.co/{repo_type}s/{repo_id}"
+
+                        print(f"Repository: {repo_id}")
+                        print(f"Type: {repo_type}")
+                        print(f"URL: {repo_url}")
+
+                        if operation == "delete_branch":
+                            branch = arguments.get("branch", "")
+                            print(f"Branch to delete: {branch}")
+
+                        elif operation == "delete_tag":
+                            tag = arguments.get("tag", "")
+                            print(f"Tag to delete: {tag}")
+
+                        elif operation == "merge_pr":
+                            pr_num = arguments.get("pr_num", "")
+                            print(f"PR to merge: #{pr_num}")
+
+                        elif operation == "create_repo":
+                            private = arguments.get("private", False)
+                            space_sdk = arguments.get("space_sdk")
+                            print(f"Private: {private}")
+                            if space_sdk:
+                                print(f"Space SDK: {space_sdk}")
+
+                        elif operation == "update_repo":
+                            private = arguments.get("private")
+                            gated = arguments.get("gated")
+                            if private is not None:
+                                print(f"Private: {private}")
+                            if gated is not None:
+                                print(f"Gated: {gated}")
+
                     # Get user decision for this item
                     response = await prompt_session.prompt_async(
                         f"Approve item {i}? (y=yes, yolo=approve all, n=no, or provide feedback): "

agent/tools/hf_repo_files_tool.py

@@ -0,0 +1,322 @@
+"""
+HF Repo Files Tool - File operations on Hugging Face repositories
+
+Operations: list, read, upload, delete
+"""
+
+import asyncio
+from typing import Any, Dict, Literal, Optional
+
+from huggingface_hub import HfApi, hf_hub_download
+from huggingface_hub.utils import EntryNotFoundError, RepositoryNotFoundError
+
+from agent.tools.types import ToolResult
+
+OperationType = Literal["list", "read", "upload", "delete"]
+
+
+async def _async_call(func, *args, **kwargs):
+    """Wrap synchronous HfApi calls for async context."""
+    return await asyncio.to_thread(func, *args, **kwargs)
+
+
+def _build_repo_url(repo_id: str, repo_type: str = "model") -> str:
+    """Build the Hub URL for a repository."""
+    if repo_type == "model":
+        return f"https://huggingface.co/{repo_id}"
+    return f"https://huggingface.co/{repo_type}s/{repo_id}"
+
+
+def _format_size(size_bytes: int) -> str:
+    """Format file size in human-readable form."""
+    for unit in ["B", "KB", "MB", "GB", "TB"]:
+        if size_bytes < 1024:
+            return f"{size_bytes:.1f}{unit}"
+        size_bytes /= 1024
+    return f"{size_bytes:.1f}PB"
+
+
+class HfRepoFilesTool:
+    """Tool for file operations on HF repos."""
+
+    def __init__(self, hf_token: Optional[str] = None):
+        self.api = HfApi(token=hf_token)
+
+    async def execute(self, args: Dict[str, Any]) -> ToolResult:
+        """Execute the specified operation."""
+        operation = args.get("operation")
+
+        if not operation:
+            return self._help()
+
+        try:
+            handlers = {
+                "list": self._list,
+                "read": self._read,
+                "upload": self._upload,
+                "delete": self._delete,
+            }
+
+            handler = handlers.get(operation)
+            if handler:
+                return await handler(args)
+            else:
+                return self._error(f"Unknown operation: {operation}. Valid: list, read, upload, delete")
+
+        except RepositoryNotFoundError:
+            return self._error(f"Repository not found: {args.get('repo_id')}")
+        except EntryNotFoundError:
+            return self._error(f"File not found: {args.get('path')}")
+        except Exception as e:
+            return self._error(f"Error: {str(e)}")
+
+    def _help(self) -> ToolResult:
+        """Show usage instructions."""
+        return {
+            "formatted": """**hf_repo_files** - File operations on HF repos
+
+**Operations:**
+- `list` - List files: `{"operation": "list", "repo_id": "gpt2"}`
+- `read` - Read file: `{"operation": "read", "repo_id": "gpt2", "path": "config.json"}`
+- `upload` - Upload: `{"operation": "upload", "repo_id": "my-model", "path": "README.md", "content": "..."}`
+- `delete` - Delete: `{"operation": "delete", "repo_id": "my-model", "patterns": ["*.tmp"]}`
+
+**Common params:** repo_id (required), repo_type (model/dataset/space), revision (default: main)""",
+            "totalResults": 1,
+            "resultsShared": 1,
+        }
+
+    async def _list(self, args: Dict[str, Any]) -> ToolResult:
+        """List files in a repository."""
+        repo_id = args.get("repo_id")
+        if not repo_id:
+            return self._error("repo_id is required")
+
+        repo_type = args.get("repo_type", "model")
+        revision = args.get("revision", "main")
+        path = args.get("path", "")
+
+        items = list(await _async_call(
+            self.api.list_repo_tree,
+            repo_id=repo_id,
+            repo_type=repo_type,
+            revision=revision,
+            path_in_repo=path,
+            recursive=True,
+        ))
+
+        if not items:
+            return {"formatted": f"No files in {repo_id}", "totalResults": 0, "resultsShared": 0}
+
+        lines = []
+        total_size = 0
+        for item in sorted(items, key=lambda x: x.path):
+            if hasattr(item, "size") and item.size:
+                total_size += item.size
+                lines.append(f"{item.path} ({_format_size(item.size)})")
+            else:
+                lines.append(f"{item.path}/")
+
+        url = _build_repo_url(repo_id, repo_type)
+        response = f"**{repo_id}** ({len(items)} files, {_format_size(total_size)})\n{url}/tree/{revision}\n\n" + "\n".join(lines)
+
+        return {"formatted": response, "totalResults": len(items), "resultsShared": len(items)}
+
+    async def _read(self, args: Dict[str, Any]) -> ToolResult:
+        """Read file content from a repository."""
+        repo_id = args.get("repo_id")
+        path = args.get("path")
+
+        if not repo_id:
+            return self._error("repo_id is required")
+        if not path:
+            return self._error("path is required")
+
+        repo_type = args.get("repo_type", "model")
+        revision = args.get("revision", "main")
+        max_chars = args.get("max_chars", 50000)
+
+        file_path = await _async_call(
+            hf_hub_download,
+            repo_id=repo_id,
+            filename=path,
+            repo_type=repo_type,
+            revision=revision,
+            token=self.api.token,
+        )
+
+        try:
+            with open(file_path, "r", encoding="utf-8") as f:
+                content = f.read()
+
+            truncated = len(content) > max_chars
+            if truncated:
+                content = content[:max_chars]
+
+            url = f"{_build_repo_url(repo_id, repo_type)}/blob/{revision}/{path}"
+            response = f"**{path}**{' (truncated)' if truncated else ''}\n{url}\n\n```\n{content}\n```"
+
+            return {"formatted": response, "totalResults": 1, "resultsShared": 1}
+
+        except UnicodeDecodeError:
+            import os
+            size = os.path.getsize(file_path)
+            return {"formatted": f"Binary file ({_format_size(size)})", "totalResults": 1, "resultsShared": 1}
+
+    async def _upload(self, args: Dict[str, Any]) -> ToolResult:
+        """Upload content to a repository."""
+        repo_id = args.get("repo_id")
+        path = args.get("path")
+        content = args.get("content")
+
+        if not repo_id:
+            return self._error("repo_id is required")
+        if not path:
+            return self._error("path is required")
+        if content is None:
+            return self._error("content is required")
+
+        repo_type = args.get("repo_type", "model")
+        revision = args.get("revision", "main")
+        create_pr = args.get("create_pr", False)
+        commit_message = args.get("commit_message", f"Upload {path}")
+
+        file_bytes = content.encode("utf-8") if isinstance(content, str) else content
+
+        result = await _async_call(
+            self.api.upload_file,
+            path_or_fileobj=file_bytes,
+            path_in_repo=path,
+            repo_id=repo_id,
+            repo_type=repo_type,
+            revision=revision,
+            commit_message=commit_message,
+            create_pr=create_pr,
+        )
+
+        url = _build_repo_url(repo_id, repo_type)
+        if create_pr and hasattr(result, "pr_url"):
+            response = f"**Uploaded as PR**\n{result.pr_url}"
+        else:
+            response = f"**Uploaded:** {path}\n{url}/blob/{revision}/{path}"
+
+        return {"formatted": response, "totalResults": 1, "resultsShared": 1}
+
+    async def _delete(self, args: Dict[str, Any]) -> ToolResult:
+        """Delete files from a repository."""
+        repo_id = args.get("repo_id")
+        patterns = args.get("patterns")
+
+        if not repo_id:
+            return self._error("repo_id is required")
+        if not patterns:
+            return self._error("patterns is required (list of paths/wildcards)")
+
+        if isinstance(patterns, str):
+            patterns = [patterns]
+
+        repo_type = args.get("repo_type", "model")
+        revision = args.get("revision", "main")
+        create_pr = args.get("create_pr", False)
+        commit_message = args.get("commit_message", f"Delete {', '.join(patterns)}")
+
+        await _async_call(
+            self.api.delete_files,
+            repo_id=repo_id,
+            delete_patterns=patterns,
+            repo_type=repo_type,
+            revision=revision,
+            commit_message=commit_message,
+            create_pr=create_pr,
+        )
+
+        response = f"**Deleted:** {', '.join(patterns)} from {repo_id}"
+        return {"formatted": response, "totalResults": 1, "resultsShared": 1}
+
+    def _error(self, message: str) -> ToolResult:
+        """Return an error result."""
+        return {"formatted": message, "totalResults": 0, "resultsShared": 0, "isError": True}
+
+
+# Tool specification
+HF_REPO_FILES_TOOL_SPEC = {
+    "name": "hf_repo_files",
+    "description": (
+        "Read and write files in HF repos (models/datasets/spaces).\n\n"
+        "## Operations\n"
+        "- **list**: List files with sizes and structure\n"
+        "- **read**: Read file content (text files only)\n"
+        "- **upload**: Upload content to repo (can create PR)\n"
+        "- **delete**: Delete files/folders (supports wildcards like *.tmp)\n\n"
+        "## Use when\n"
+        "- Need to see what files exist in a repo\n"
+        "- Want to read config.json, README.md, or other text files\n"
+        "- Uploading training scripts, configs, or results to a repo\n"
+        "- Cleaning up temporary files from a repo\n\n"
+        "## Examples\n"
+        '{"operation": "list", "repo_id": "meta-llama/Llama-2-7b"}\n'
+        '{"operation": "read", "repo_id": "gpt2", "path": "config.json"}\n'
+        '{"operation": "upload", "repo_id": "my-model", "path": "README.md", "content": "# My Model"}\n'
+        '{"operation": "upload", "repo_id": "org/model", "path": "fix.py", "content": "...", "create_pr": true}\n'
+        '{"operation": "delete", "repo_id": "my-model", "patterns": ["*.tmp", "logs/"]}\n\n'
+        "## Notes\n"
+        "- For binary files (safetensors, bin), use list to see them but can't read content\n"
+        "- upload/delete require approval (can overwrite/destroy data)\n"
+        "- Use create_pr=true to propose changes instead of direct commit\n"
+    ),
+    "parameters": {
+        "type": "object",
+        "properties": {
+            "operation": {
+                "type": "string",
+                "enum": ["list", "read", "upload", "delete"],
+                "description": "Operation: list, read, upload, delete",
+            },
+            "repo_id": {
+                "type": "string",
+                "description": "Repository ID (e.g., 'username/repo-name')",
+            },
+            "repo_type": {
+                "type": "string",
+                "enum": ["model", "dataset", "space"],
+                "description": "Repository type (default: model)",
+            },
+            "revision": {
+                "type": "string",
+                "description": "Branch/tag/commit (default: main)",
+            },
+            "path": {
+                "type": "string",
+                "description": "File path for read/upload",
+            },
+            "content": {
+                "type": "string",
+                "description": "File content for upload",
+            },
+            "patterns": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": "Patterns to delete (e.g., ['*.tmp', 'logs/'])",
+            },
+            "create_pr": {
+                "type": "boolean",
+                "description": "Create PR instead of direct commit",
+            },
+            "commit_message": {
+                "type": "string",
+                "description": "Custom commit message",
+            },
+        },
+        "required": ["operation"],
+    },
+}
+
+
+async def hf_repo_files_handler(arguments: Dict[str, Any]) -> tuple[str, bool]:
+    """Handler for agent tool router."""
+    try:
+        tool = HfRepoFilesTool()
+        result = await tool.execute(arguments)
+        return result["formatted"], not result.get("isError", False)
+    except Exception as e:
+        return f"Error: {str(e)}", False

agent/tools/hf_repo_git_tool.py

@@ -0,0 +1,663 @@
+"""
+HF Repo Git Tool - Git-like operations on Hugging Face repositories
+
+Operations: branches, tags, PRs, repo management
+"""
+
+import asyncio
+from typing import Any, Dict, Literal, Optional
+
+from huggingface_hub import HfApi
+from huggingface_hub.utils import RepositoryNotFoundError
+
+from agent.tools.types import ToolResult
+
+OperationType = Literal[
+    "create_branch", "delete_branch",
+    "create_tag", "delete_tag",
+    "list_refs",
+    "create_pr", "list_prs", "get_pr", "merge_pr", "close_pr", "comment_pr", "change_pr_status",
+    "create_repo", "update_repo",
+]
+
+
+async def _async_call(func, *args, **kwargs):
+    """Wrap synchronous HfApi calls for async context."""
+    return await asyncio.to_thread(func, *args, **kwargs)
+
+
+def _build_repo_url(repo_id: str, repo_type: str = "model") -> str:
+    """Build the Hub URL for a repository."""
+    if repo_type == "model":
+        return f"https://huggingface.co/{repo_id}"
+    return f"https://huggingface.co/{repo_type}s/{repo_id}"
+
+
+class HfRepoGitTool:
+    """Tool for git-like operations on HF repos."""
+
+    def __init__(self, hf_token: Optional[str] = None):
+        self.api = HfApi(token=hf_token)
+
+    async def execute(self, args: Dict[str, Any]) -> ToolResult:
+        """Execute the specified operation."""
+        operation = args.get("operation")
+
+        if not operation:
+            return self._help()
+
+        try:
+            handlers = {
+                "create_branch": self._create_branch,
+                "delete_branch": self._delete_branch,
+                "create_tag": self._create_tag,
+                "delete_tag": self._delete_tag,
+                "list_refs": self._list_refs,
+                "create_pr": self._create_pr,
+                "list_prs": self._list_prs,
+                "get_pr": self._get_pr,
+                "merge_pr": self._merge_pr,
+                "close_pr": self._close_pr,
+                "comment_pr": self._comment_pr,
+                "change_pr_status": self._change_pr_status,
+                "create_repo": self._create_repo,
+                "update_repo": self._update_repo,
+            }
+
+            handler = handlers.get(operation)
+            if handler:
+                return await handler(args)
+            else:
+                ops = ", ".join(handlers.keys())
+                return self._error(f"Unknown operation: {operation}. Valid: {ops}")
+
+        except RepositoryNotFoundError:
+            return self._error(f"Repository not found: {args.get('repo_id')}")
+        except Exception as e:
+            return self._error(f"Error: {str(e)}")
+
+    def _help(self) -> ToolResult:
+        """Show usage instructions."""
+        return {
+            "formatted": """**hf_repo_git** - Git-like operations on HF repos
+
+**Branch/Tag:**
+- `create_branch`: `{"operation": "create_branch", "repo_id": "...", "branch": "dev"}`
+- `delete_branch`: `{"operation": "delete_branch", "repo_id": "...", "branch": "dev"}`
+- `create_tag`: `{"operation": "create_tag", "repo_id": "...", "tag": "v1.0"}`
+- `delete_tag`: `{"operation": "delete_tag", "repo_id": "...", "tag": "v1.0"}`
+- `list_refs`: `{"operation": "list_refs", "repo_id": "..."}`
+
+**PRs:**
+- `create_pr`: `{"operation": "create_pr", "repo_id": "...", "title": "..."}` (creates draft PR)
+- `list_prs`: `{"operation": "list_prs", "repo_id": "..."}` (shows status: draft/open/merged/closed)
+- `get_pr`: `{"operation": "get_pr", "repo_id": "...", "pr_num": 1}` (shows status)
+- `change_pr_status`: `{"operation": "change_pr_status", "repo_id": "...", "pr_num": 1, "new_status": "open"}` (change draft to open)
+- `merge_pr`: `{"operation": "merge_pr", "repo_id": "...", "pr_num": 1}`
+- `close_pr`: `{"operation": "close_pr", "repo_id": "...", "pr_num": 1}`
+- `comment_pr`: `{"operation": "comment_pr", "repo_id": "...", "pr_num": 1, "comment": "..."}`
+
+**Repo:**
+- `create_repo`: `{"operation": "create_repo", "repo_id": "my-model", "private": true}`
+- `update_repo`: `{"operation": "update_repo", "repo_id": "...", "private": false}`""",
+            "totalResults": 1,
+            "resultsShared": 1,
+        }
+
+    # =========================================================================
+    # BRANCH OPERATIONS
+    # =========================================================================
+
+    async def _create_branch(self, args: Dict[str, Any]) -> ToolResult:
+        """Create a new branch."""
+        repo_id = args.get("repo_id")
+        branch = args.get("branch")
+
+        if not repo_id:
+            return self._error("repo_id is required")
+        if not branch:
+            return self._error("branch is required")
+
+        repo_type = args.get("repo_type", "model")
+        from_rev = args.get("from_rev", "main")
+
+        await _async_call(
+            self.api.create_branch,
+            repo_id=repo_id,
+            branch=branch,
+            revision=from_rev,
+            repo_type=repo_type,
+            exist_ok=args.get("exist_ok", False),
+        )
+
+        url = f"{_build_repo_url(repo_id, repo_type)}/tree/{branch}"
+        return {"formatted": f"**Branch created:** {branch}\n{url}", "totalResults": 1, "resultsShared": 1}
+
+    async def _delete_branch(self, args: Dict[str, Any]) -> ToolResult:
+        """Delete a branch."""
+        repo_id = args.get("repo_id")
+        branch = args.get("branch")
+
+        if not repo_id:
+            return self._error("repo_id is required")
+        if not branch:
+            return self._error("branch is required")
+
+        repo_type = args.get("repo_type", "model")
+
+        await _async_call(
+            self.api.delete_branch,
+            repo_id=repo_id,
+            branch=branch,
+            repo_type=repo_type,
+        )
+
+        return {"formatted": f"**Branch deleted:** {branch}", "totalResults": 1, "resultsShared": 1}
+
+    # =========================================================================
+    # TAG OPERATIONS
+    # =========================================================================
+
+    async def _create_tag(self, args: Dict[str, Any]) -> ToolResult:
+        """Create a tag."""
+        repo_id = args.get("repo_id")
+        tag = args.get("tag")
+
+        if not repo_id:
+            return self._error("repo_id is required")
+        if not tag:
+            return self._error("tag is required")
+
+        repo_type = args.get("repo_type", "model")
+        revision = args.get("revision", "main")
+        tag_message = args.get("tag_message", "")
+
+        await _async_call(
+            self.api.create_tag,
+            repo_id=repo_id,
+            tag=tag,
+            revision=revision,
+            tag_message=tag_message,
+            repo_type=repo_type,
+            exist_ok=args.get("exist_ok", False),
+        )
+
+        url = f"{_build_repo_url(repo_id, repo_type)}/tree/{tag}"
+        return {"formatted": f"**Tag created:** {tag}\n{url}", "totalResults": 1, "resultsShared": 1}
+
+    async def _delete_tag(self, args: Dict[str, Any]) -> ToolResult:
+        """Delete a tag."""
+        repo_id = args.get("repo_id")
+        tag = args.get("tag")
+
+        if not repo_id:
+            return self._error("repo_id is required")
+        if not tag:
+            return self._error("tag is required")
+
+        repo_type = args.get("repo_type", "model")
+
+        await _async_call(
+            self.api.delete_tag,
+            repo_id=repo_id,
+            tag=tag,
+            repo_type=repo_type,
+        )
+
+        return {"formatted": f"**Tag deleted:** {tag}", "totalResults": 1, "resultsShared": 1}
+
+    # =========================================================================
+    # LIST REFS
+    # =========================================================================
+
+    async def _list_refs(self, args: Dict[str, Any]) -> ToolResult:
+        """List branches and tags."""
+        repo_id = args.get("repo_id")
+
+        if not repo_id:
+            return self._error("repo_id is required")
+
+        repo_type = args.get("repo_type", "model")
+
+        refs = await _async_call(
+            self.api.list_repo_refs,
+            repo_id=repo_id,
+            repo_type=repo_type,
+        )
+
+        branches = [b.name for b in refs.branches] if refs.branches else []
+        tags = [t.name for t in refs.tags] if hasattr(refs, 'tags') and refs.tags else []
+
+        url = _build_repo_url(repo_id, repo_type)
+        lines = [f"**{repo_id}**", url, ""]
+
+        if branches:
+            lines.append(f"**Branches ({len(branches)}):** " + ", ".join(branches))
+        else:
+            lines.append("**Branches:** none")
+
+        if tags:
+            lines.append(f"**Tags ({len(tags)}):** " + ", ".join(tags))
+        else:
+            lines.append("**Tags:** none")
+
+        return {"formatted": "\n".join(lines), "totalResults": len(branches) + len(tags), "resultsShared": len(branches) + len(tags)}
+
+    # =========================================================================
+    # PR OPERATIONS
+    # =========================================================================
+
+    async def _create_pr(self, args: Dict[str, Any]) -> ToolResult:
+        """Create a pull request."""
+        repo_id = args.get("repo_id")
+        title = args.get("title")
+
+        if not repo_id:
+            return self._error("repo_id is required")
+        if not title:
+            return self._error("title is required")
+
+        repo_type = args.get("repo_type", "model")
+        description = args.get("description", "")
+
+        result = await _async_call(
+            self.api.create_pull_request,
+            repo_id=repo_id,
+            title=title,
+            description=description,
+            repo_type=repo_type,
+        )
+
+        url = f"{_build_repo_url(repo_id, repo_type)}/discussions/{result.num}"
+        return {
+            "formatted": f"**Draft PR #{result.num} created:** {title}\n{url}\n\nAdd commits via upload with revision=\"refs/pr/{result.num}\"",
+            "totalResults": 1,
+            "resultsShared": 1,
+        }
+
+    async def _list_prs(self, args: Dict[str, Any]) -> ToolResult:
+        """List PRs and discussions."""
+        repo_id = args.get("repo_id")
+
+        if not repo_id:
+            return self._error("repo_id is required")
+
+        repo_type = args.get("repo_type", "model")
+        status = args.get("status", "all")  # open, closed, all
+
+        discussions = list(self.api.get_repo_discussions(
+            repo_id=repo_id,
+            repo_type=repo_type,
+            discussion_status=status if status != "all" else None,
+        ))
+
+        if not discussions:
+            return {"formatted": f"No discussions in {repo_id}", "totalResults": 0, "resultsShared": 0}
+
+        url = _build_repo_url(repo_id, repo_type)
+        lines = [f"**{repo_id}** - {len(discussions)} discussions", f"{url}/discussions", ""]
+
+        for d in discussions[:20]:
+            if d.status == "draft":
+                status_label = "[DRAFT]"
+            elif d.status == "open":
+                status_label = "[OPEN]"
+            elif d.status == "merged":
+                status_label = "[MERGED]"
+            else:
+                status_label = "[CLOSED]"
+            type_label = "PR" if d.is_pull_request else "D"
+            lines.append(f"{status_label} #{d.num} [{type_label}] {d.title}")
+
+        return {"formatted": "\n".join(lines), "totalResults": len(discussions), "resultsShared": min(20, len(discussions))}
+
+    async def _get_pr(self, args: Dict[str, Any]) -> ToolResult:
+        """Get PR details."""
+        repo_id = args.get("repo_id")
+        pr_num = args.get("pr_num")
+
+        if not repo_id:
+            return self._error("repo_id is required")
+        if not pr_num:
+            return self._error("pr_num is required")
+
+        repo_type = args.get("repo_type", "model")
+
+        pr = await _async_call(
+            self.api.get_discussion_details,
+            repo_id=repo_id,
+            discussion_num=int(pr_num),
+            repo_type=repo_type,
+        )
+
+        url = f"{_build_repo_url(repo_id, repo_type)}/discussions/{pr_num}"
+        status_map = {
+            "draft": "Draft",
+            "open": "Open",
+            "merged": "Merged",
+            "closed": "Closed"
+        }
+        status = status_map.get(pr.status, pr.status.capitalize())
+        type_label = "Pull Request" if pr.is_pull_request else "Discussion"
+
+        lines = [
+            f"**{type_label} #{pr_num}:** {pr.title}",
+            f"**Status:** {status}",
+            f"**Author:** {pr.author}",
+            url,
+        ]
+
+        if pr.is_pull_request:
+            if pr.status == "draft":
+                lines.append(f"\nTo add commits: upload with revision=\"refs/pr/{pr_num}\"")
+            elif pr.status == "open":
+                lines.append(f"\nTo add commits: upload with revision=\"refs/pr/{pr_num}\"")
+
+        return {"formatted": "\n".join(lines), "totalResults": 1, "resultsShared": 1}
+
+    async def _merge_pr(self, args: Dict[str, Any]) -> ToolResult:
+        """Merge a pull request."""
+        repo_id = args.get("repo_id")
+        pr_num = args.get("pr_num")
+
+        if not repo_id:
+            return self._error("repo_id is required")
+        if not pr_num:
+            return self._error("pr_num is required")
+
+        repo_type = args.get("repo_type", "model")
+        comment = args.get("comment", "")
+
+        await _async_call(
+            self.api.merge_pull_request,
+            repo_id=repo_id,
+            discussion_num=int(pr_num),
+            comment=comment,
+            repo_type=repo_type,
+        )
+
+        url = f"{_build_repo_url(repo_id, repo_type)}/discussions/{pr_num}"
+        return {"formatted": f"**PR #{pr_num} merged**\n{url}", "totalResults": 1, "resultsShared": 1}
+
+    async def _close_pr(self, args: Dict[str, Any]) -> ToolResult:
+        """Close a PR/discussion."""
+        repo_id = args.get("repo_id")
+        pr_num = args.get("pr_num")
+
+        if not repo_id:
+            return self._error("repo_id is required")
+        if not pr_num:
+            return self._error("pr_num is required")
+
+        repo_type = args.get("repo_type", "model")
+        comment = args.get("comment", "")
+
+        await _async_call(
+            self.api.change_discussion_status,
+            repo_id=repo_id,
+            discussion_num=int(pr_num),
+            new_status="closed",
+            comment=comment,
+            repo_type=repo_type,
+        )
+
+        return {"formatted": f"**Discussion #{pr_num} closed**", "totalResults": 1, "resultsShared": 1}
+
+    async def _comment_pr(self, args: Dict[str, Any]) -> ToolResult:
+        """Add a comment to a PR/discussion."""
+        repo_id = args.get("repo_id")
+        pr_num = args.get("pr_num")
+        comment = args.get("comment")
+
+        if not repo_id:
+            return self._error("repo_id is required")
+        if not pr_num:
+            return self._error("pr_num is required")
+        if not comment:
+            return self._error("comment is required")
+
+        repo_type = args.get("repo_type", "model")
+
+        await _async_call(
+            self.api.comment_discussion,
+            repo_id=repo_id,
+            discussion_num=int(pr_num),
+            comment=comment,
+            repo_type=repo_type,
+        )
+
+        url = f"{_build_repo_url(repo_id, repo_type)}/discussions/{pr_num}"
+        return {"formatted": f"**Comment added to #{pr_num}**\n{url}", "totalResults": 1, "resultsShared": 1}
+
+    async def _change_pr_status(self, args: Dict[str, Any]) -> ToolResult:
+        """Change PR/discussion status (mainly to convert draft to open)."""
+        repo_id = args.get("repo_id")
+        pr_num = args.get("pr_num")
+        new_status = args.get("new_status")
+
+        if not repo_id:
+            return self._error("repo_id is required")
+        if not pr_num:
+            return self._error("pr_num is required")
+        if not new_status:
+            return self._error("new_status is required (open or closed)")
+
+        repo_type = args.get("repo_type", "model")
+        comment = args.get("comment", "")
+
+        await _async_call(
+            self.api.change_discussion_status,
+            repo_id=repo_id,
+            discussion_num=int(pr_num),
+            new_status=new_status,
+            comment=comment,
+            repo_type=repo_type,
+        )
+
+        url = f"{_build_repo_url(repo_id, repo_type)}/discussions/{pr_num}"
+        return {"formatted": f"**PR #{pr_num} status changed to {new_status}**\n{url}", "totalResults": 1, "resultsShared": 1}
+
+    # =========================================================================
+    # REPO MANAGEMENT
+    # =========================================================================
+
+    async def _create_repo(self, args: Dict[str, Any]) -> ToolResult:
+        """Create a new repository."""
+        repo_id = args.get("repo_id")
+
+        if not repo_id:
+            return self._error("repo_id is required")
+
+        repo_type = args.get("repo_type", "model")
+        private = args.get("private", True)
+        space_sdk = args.get("space_sdk")
+
+        if repo_type == "space" and not space_sdk:
+            return self._error("space_sdk required for spaces (gradio/streamlit/docker/static)")
+
+        kwargs = {
+            "repo_id": repo_id,
+            "repo_type": repo_type,
+            "private": private,
+            "exist_ok": args.get("exist_ok", False),
+        }
+        if space_sdk:
+            kwargs["space_sdk"] = space_sdk
+
+        result = await _async_call(self.api.create_repo, **kwargs)
+
+        return {
+            "formatted": f"**Repository created:** {repo_id}\n**Private:** {private}\n{result}",
+            "totalResults": 1,
+            "resultsShared": 1,
+        }
+
+    async def _update_repo(self, args: Dict[str, Any]) -> ToolResult:
+        """Update repository settings."""
+        repo_id = args.get("repo_id")
+
+        if not repo_id:
+            return self._error("repo_id is required")
+
+        repo_type = args.get("repo_type", "model")
+        private = args.get("private")
+        gated = args.get("gated")
+
+        if private is None and gated is None:
+            return self._error("Specify private (bool) or gated ('auto'/'manual'/false)")
+
+        kwargs = {"repo_id": repo_id, "repo_type": repo_type}
+        if private is not None:
+            kwargs["private"] = private
+        if gated is not None:
+            kwargs["gated"] = gated
+
+        await _async_call(self.api.update_repo_settings, **kwargs)
+
+        changes = []
+        if private is not None:
+            changes.append(f"private={private}")
+        if gated is not None:
+            changes.append(f"gated={gated}")
+
+        url = f"{_build_repo_url(repo_id, repo_type)}/settings"
+        return {"formatted": f"**Settings updated:** {', '.join(changes)}\n{url}", "totalResults": 1, "resultsShared": 1}
+
+    def _error(self, message: str) -> ToolResult:
+        """Return an error result."""
+        return {"formatted": message, "totalResults": 0, "resultsShared": 0, "isError": True}
+
+
+# Tool specification
+HF_REPO_GIT_TOOL_SPEC = {
+    "name": "hf_repo_git",
+    "description": (
+        "Git-like operations on HF repos: branches, tags, PRs, and repo management.\n\n"
+        "## Operations\n"
+        "**Branches:** create_branch, delete_branch, list_refs\n"
+        "**Tags:** create_tag, delete_tag\n"
+        "**PRs:** create_pr, list_prs, get_pr, merge_pr, close_pr, comment_pr, change_pr_status\n"
+        "**Repo:** create_repo, update_repo\n\n"
+        "## Use when\n"
+        "- Creating feature branches for experiments\n"
+        "- Tagging model versions (v1.0, v2.0)\n"
+        "- Opening PRs to contribute to repos you don't own\n"
+        "- Reviewing and merging PRs on your repos\n"
+        "- Creating new model/dataset/space repos\n"
+        "- Changing repo visibility (public/private) or gated access\n\n"
+        "## Examples\n"
+        '{"operation": "list_refs", "repo_id": "my-model"}\n'
+        '{"operation": "create_branch", "repo_id": "my-model", "branch": "experiment-v2"}\n'
+        '{"operation": "create_tag", "repo_id": "my-model", "tag": "v1.0", "revision": "main"}\n'
+        '{"operation": "create_pr", "repo_id": "org/model", "title": "Fix tokenizer config"}\n'
+        '{"operation": "change_pr_status", "repo_id": "my-model", "pr_num": 1, "new_status": "open"}\n'
+        '{"operation": "merge_pr", "repo_id": "my-model", "pr_num": 3}\n'
+        '{"operation": "create_repo", "repo_id": "my-new-model", "private": true}\n'
+        '{"operation": "update_repo", "repo_id": "my-model", "gated": "auto"}\n\n'
+        "## PR Workflow\n"
+        "1. create_pr → creates draft PR (empty by default)\n"
+        "2. Upload files with revision='refs/pr/N' to add commits\n"
+        "3. change_pr_status with new_status='open' to publish (convert draft to open)\n"
+        "4. merge_pr when ready\n\n"
+        "## Notes\n"
+        "- PR status: draft (default), open, merged, closed\n"
+        "- delete_branch, delete_tag, merge_pr, create_repo, update_repo require approval\n"
+        "- For spaces, create_repo needs space_sdk (gradio/streamlit/docker/static)\n"
+        "- gated options: 'auto' (instant), 'manual' (review), false (open)\n"
+    ),
+    "parameters": {
+        "type": "object",
+        "properties": {
+            "operation": {
+                "type": "string",
+                "enum": [
+                    "create_branch", "delete_branch",
+                    "create_tag", "delete_tag", "list_refs",
+                    "create_pr", "list_prs", "get_pr", "merge_pr", "close_pr", "comment_pr", "change_pr_status",
+                    "create_repo", "update_repo",
+                ],
+                "description": "Operation to execute",
+            },
+            "repo_id": {
+                "type": "string",
+                "description": "Repository ID (e.g., 'username/repo-name')",
+            },
+            "repo_type": {
+                "type": "string",
+                "enum": ["model", "dataset", "space"],
+                "description": "Repository type (default: model)",
+            },
+            "branch": {
+                "type": "string",
+                "description": "Branch name (create_branch, delete_branch)",
+            },
+            "from_rev": {
+                "type": "string",
+                "description": "Create branch from this revision (default: main)",
+            },
+            "tag": {
+                "type": "string",
+                "description": "Tag name (create_tag, delete_tag)",
+            },
+            "revision": {
+                "type": "string",
+                "description": "Revision for tag (default: main)",
+            },
+            "tag_message": {
+                "type": "string",
+                "description": "Tag description",
+            },
+            "title": {
+                "type": "string",
+                "description": "PR title (create_pr)",
+            },
+            "description": {
+                "type": "string",
+                "description": "PR description (create_pr)",
+            },
+            "pr_num": {
+                "type": "integer",
+                "description": "PR/discussion number",
+            },
+            "comment": {
+                "type": "string",
+                "description": "Comment text",
+            },
+            "status": {
+                "type": "string",
+                "enum": ["open", "closed", "all"],
+                "description": "Filter PRs by status (list_prs)",
+            },
+            "new_status": {
+                "type": "string",
+                "enum": ["open", "closed"],
+                "description": "New status for PR/discussion (change_pr_status)",
+            },
+            "private": {
+                "type": "boolean",
+                "description": "Make repo private (create_repo, update_repo)",
+            },
+            "gated": {
+                "type": "string",
+                "enum": ["auto", "manual", "false"],
+                "description": "Gated access setting (update_repo)",
+            },
+            "space_sdk": {
+                "type": "string",
+                "enum": ["gradio", "streamlit", "docker", "static"],
+                "description": "Space SDK (required for create_repo with space)",
+            },
+        },
+        "required": ["operation"],
+    },
+}
+
+
+async def hf_repo_git_handler(arguments: Dict[str, Any]) -> tuple[str, bool]:
+    """Handler for agent tool router."""
+    try:
+        tool = HfRepoGitTool()
+        result = await tool.execute(arguments)
+        return result["formatted"], not result.get("isError", False)
+    except Exception as e:
+        return f"Error: {str(e)}", False

agent/tools/utils_tools.py

@@ -1,203 +0,0 @@
-"""
-Utils Tools - General utility operations
-
-Provides system information like current date/time with timezone support.
-"""
-
-import zoneinfo
-from datetime import datetime
-from typing import Any, Dict, Literal
-
-from agent.tools.types import ToolResult
-
-# Operation names
-OperationType = Literal["get_datetime"]
-
-
-class UtilsTool:
-    """Tool for general utility operations."""
-
-    async def execute(self, params: Dict[str, Any]) -> ToolResult:
-        """Execute the specified utility operation."""
-        operation = params.get("operation")
-        args = params.get("args", {})
-
-        # If no operation provided, return usage instructions
-        if not operation:
-            return self._show_help()
-
-        # Normalize operation name
-        operation = operation.lower()
-
-        # Check if help is requested
-        if args.get("help"):
-            return self._show_operation_help(operation)
-
-        try:
-            # Route to appropriate handler
-            if operation == "get_datetime":
-                return await self._get_datetime(args)
-            else:
-                return {
-                    "formatted": f'Unknown operation: "{operation}"\n\n'
-                    "Available operations: get_datetime\n\n"
-                    "Call this tool with no operation for full usage instructions.",
-                    "totalResults": 0,
-                    "resultsShared": 0,
-                    "isError": True,
-                }
-
-        except Exception as e:
-            return {
-                "formatted": f"Error executing {operation}: {str(e)}",
-                "totalResults": 0,
-                "resultsShared": 0,
-                "isError": True,
-            }
-
-    def _show_help(self) -> ToolResult:
-        """Show usage instructions when tool is called with no arguments."""
-        usage_text = """# Utils Tool
-
-Utility operations for system information.
-
-## Available Commands
-
-- **get_datetime** - Get current date and time with timezone support
-
-## Examples
-
-### Get current date and time (Paris timezone by default)
-Call this tool with:
-```json
-{
-  "operation": "get_datetime",
-  "args": {}
-}
-```
-
-### Get current date and time in a specific timezone
-Call this tool with:
-```json
-{
-  "operation": "get_datetime",
-  "args": {
-    "timezone": "America/New_York"
-  }
-}
-```
-
-Common timezones: Europe/Paris, America/New_York, America/Los_Angeles, Asia/Tokyo, UTC
-
-## Tips
-
-- **Default timezone**: Paris (Europe/Paris)
-- **Date format**: dd-mm-yyyy
-- **Time format**: HH:MM:SS.mmm (24-hour format with milliseconds)
-- **Timezone names**: Use IANA timezone database names (e.g., "Europe/Paris", "UTC")
-"""
-        return {"formatted": usage_text, "totalResults": 1, "resultsShared": 1}
-
-    def _show_operation_help(self, operation: str) -> ToolResult:
-        """Show help for a specific operation."""
-        help_text = f"Help for operation: {operation}\n\nCall with appropriate arguments. Use the main help for examples."
-        return {"formatted": help_text, "totalResults": 1, "resultsShared": 1}
-
-    async def _get_datetime(self, args: Dict[str, Any]) -> ToolResult:
-        """Get current date and time with timezone support."""
-        timezone_name = args.get("timezone", "Europe/Paris")
-
-        try:
-            # Get timezone object
-            tz = zoneinfo.ZoneInfo(timezone_name)
-
-            # Get current datetime in specified timezone
-            now = datetime.now(tz)
-
-            # Format date as dd-mm-yyyy
-            date_str = now.strftime("%d-%m-%Y")
-
-            # Format time as HH:MM:SS.mmm
-            time_str = now.strftime("%H:%M:%S.%f")[
-                :-3
-            ]  # Remove last 3 digits to keep only milliseconds
-
-            # Get timezone abbreviation/offset
-            tz_offset = now.strftime("%z")
-            tz_name = now.strftime("%Z")
-
-            response = f"""✓ Current date and time
-
-**Date:** {date_str}
-**Time:** {time_str}
-**Timezone:** {timezone_name} ({tz_name}, UTC{tz_offset[:3]}:{tz_offset[3:]})
-
-**ISO Format:** {now.isoformat()}
-**Unix Timestamp:** {int(now.timestamp())}"""
-
-            return {"formatted": response, "totalResults": 1, "resultsShared": 1}
-
-        except zoneinfo.ZoneInfoNotFoundError:
-            return {
-                "formatted": f"Invalid timezone: {timezone_name}\n\n"
-                "Use IANA timezone database names like:\n"
-                "- Europe/Paris\n"
-                "- America/New_York\n"
-                "- Asia/Tokyo\n"
-                "- UTC\n\n"
-                "See: https://en.wikipedia.org/wiki/List_of_tz_database_time_zones",
-                "totalResults": 0,
-                "resultsShared": 0,
-                "isError": True,
-            }
-        except Exception as e:
-            return {
-                "formatted": f"Failed to get date/time: {str(e)}",
-                "totalResults": 0,
-                "resultsShared": 0,
-                "isError": True,
-            }
-
-
-# Tool specification for agent registration
-UTILS_TOOL_SPEC = {
-    "name": "utils",
-    "description": (
-        "System utility operations - currently provides date/time with timezone support. "
-        "**Use when:** (1) Need current date for logging/timestamps, (2) User asks 'what time is it', "
-        "(3) Need timezone-aware datetime for scheduling/coordination, (4) Creating timestamped filenames. "
-        "**Operation:** get_datetime with optional timezone parameter (default: Europe/Paris). "
-        "Returns: Date (dd-mm-yyyy), time (HH:MM:SS.mmm), timezone info, ISO format, Unix timestamp. "
-        "**Pattern:** utils get_datetime → use timestamp in filename/log → upload to hf_private_repos. "
-        "Supports IANA timezone names: 'Europe/Paris', 'America/New_York', 'Asia/Tokyo', 'UTC'."
-    ),
-    "parameters": {
-        "type": "object",
-        "properties": {
-            "operation": {
-                "type": "string",
-                "enum": ["get_datetime"],
-                "description": "Operation to execute. Valid values: [get_datetime]",
-            },
-            "args": {
-                "type": "object",
-                "description": (
-                    "Operation-specific arguments as a JSON object. "
-                    "For get_datetime: timezone (string, optional, default: Europe/Paris). "
-                    "Use IANA timezone names like 'America/New_York', 'Asia/Tokyo', 'UTC'."
-                ),
-                "additionalProperties": True,
-            },
-        },
-    },
-}
-
-
-async def utils_handler(arguments: Dict[str, Any]) -> tuple[str, bool]:
-    """Handler for agent tool router."""
-    try:
-        tool = UtilsTool()
-        result = await tool.execute(arguments)
-        return result["formatted"], not result.get("isError", False)
-    except Exception as e:
-        return f"Error executing Utils tool: {str(e)}", False

test_dataset_tools.py

@@ -1,5 +1,5 @@
 """
-Test script for unified dataset inspection tool
+Test script for hf_repo_files and hf_repo_git tools
 """
 
 import asyncio
@@ -8,7 +8,7 @@ from typing import TypedDict
 from unittest.mock import MagicMock
 
 
-# Mock the types module before importing dataset_tools
+# Mock the types module before importing
 class ToolResult(TypedDict, total=False):
     formatted: str
     totalResults: int
@@ -20,60 +20,70 @@ mock_types = MagicMock()
 mock_types.ToolResult = ToolResult
 sys.modules["agent.tools.types"] = mock_types
 
-# Now import directly from the file
-sys.path.insert(0, "/Users/akseljoonas/Documents/hf-agent/agent/tools")
-from dataset_tools import hf_inspect_dataset_handler, inspect_dataset
+from agent.tools.hf_repo_files_tool import HfRepoFilesTool
+from agent.tools.hf_repo_git_tool import HfRepoGitTool
 
 
-async def test_inspect_dataset():
-    """Test the unified inspect_dataset function"""
-    print("=" * 70)
-    print("Testing inspect_dataset()")
-    print("=" * 70)
+async def test_hf_repo_files():
+    """Test hf_repo_files tool"""
+    print("=" * 60)
+    print("Testing hf_repo_files")
+    print("=" * 60)
 
-    # Test with akseljoonas/hf-agent-sessions as specified
-    print("\n→ inspect_dataset('akseljoonas/hf-agent-sessions'):")
-    result = await inspect_dataset("akseljoonas/hf-agent-sessions")
-    print(f"   isError: {result['isError']}")
-    print(f"   Output:\n{result['formatted']}")
+    tool = HfRepoFilesTool()
 
-    print("\n" + "=" * 70)
-
-    # # Test with stanfordnlp/imdb
-    # print("\n→ inspect_dataset('stanfordnlp/imdb'):")
-    # result = await inspect_dataset("stanfordnlp/imdb")
-    # print(f"   isError: {result['isError']}")
-    # print(f"   Output:\n{result['formatted']}")
-
-    # print("\n" + "=" * 70)
+    # Test list
+    print("\n→ list files in gpt2:")
+    result = await tool.execute(
+        {"operation": "list", "repo_id": "openai-community/gpt2"}
+    )
+    print(f"   isError: {result.get('isError', False)}")
+    print(f"   totalResults: {result['totalResults']}")
+    # Just show first few lines
+    lines = result["formatted"].split("\n")
+    print("   Output (first 5 lines):\n" + "\n".join(f"   {line}" for line in lines))
+
+    # Test read
+    print("\n→ read config.json from gpt2:")
+    result = await tool.execute(
+        {"operation": "read", "repo_id": "openai-community/gpt2", "path": "config.json"}
+    )
+    print(f"   isError: {result.get('isError', False)}")
+    lines = result["formatted"].split("\n")
+    print("   Output (first 10 lines):\n" + "\n".join(f"   {line}" for line in lines))
 
-    # # Test with multi-config dataset
-    # print("\n→ inspect_dataset('nyu-mll/glue', config='mrpc'):")
-    # result = await inspect_dataset("nyu-mll/glue", config="mrpc")
-    # print(f"   isError: {result['isError']}")
-    # print(f"   Output:\n{result['formatted']}")
 
+async def test_hf_repo_git():
+    """Test hf_repo_git tool"""
+    print("\n" + "=" * 60)
+    print("Testing hf_repo_git")
+    print("=" * 60)
 
-async def test_handler():
-    """Test the handler (what the agent calls)"""
-    print("\n" + "=" * 70)
-    print("Testing hf_inspect_dataset_handler()")
-    print("=" * 70)
+    tool = HfRepoGitTool()
 
-    result, success = await hf_inspect_dataset_handler(
-        {
-            "dataset": "stanfordnlp/imdb",
-            "sample_rows": 2,
-        }
+    # Test list_refs
+    print("\n→ list_refs for gpt2:")
+    result = await tool.execute(
+        {"operation": "list_refs", "repo_id": "openai-community/gpt2"}
+    )
+    print(f"   isError: {result.get('isError', False)}")
+    print(
+        "   Output:\n"
+        + "\n".join(f"   {line}" for line in result["formatted"].split("\n"))
     )
-    print("\n→ Handler result:")
-    print(f"   success: {success}")
-    print(f"   output:\n{result}")
+
+    # Test help (no operation)
+    print("\n→ help (no operation):")
+    result = await tool.execute({})
+    print(f"   isError: {result.get('isError', False)}")
+    lines = result["formatted"].split("\n")[:6]
+    print("   Output (first 6 lines):\n" + "\n".join(f"   {line}" for line in lines))
 
 
 if __name__ == "__main__":
-    print("\nUnified Dataset Inspection Tool Test\n")
-    asyncio.run(test_inspect_dataset())
-    # asyncio.run(test_handler())
-    print("\n" + "=" * 70)
-    print("Done!")
+    print("\nHF Repo Tools Test\n")
+    asyncio.run(test_hf_repo_files())
+    asyncio.run(test_hf_repo_git())
+    print("\n" + "=" * 60)
+    print("Tests complete!")
+    print("=" * 60)