hyperpocket 0.1.8__tar.gz → 0.1.9__tar.gz

{hyperpocket-0.1.8 → hyperpocket-0.1.9}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: hyperpocket
-Version: 0.1.8
+Version: 0.1.9
 Summary: Building AI agent with hyperpocket tool in a flash
 Project-URL: Homepage, https://vessl-ai.github.io/hyperpocket
 Project-URL: Repository, https://github.com/vessl-ai/hyperpocket
-Author-email: VESSL AI Devs <dev@vessl.ai>
+Author-email: Hyperpocket Team <hyperpocket@vessl.ai>
 Requires-Python: >=3.10
 Requires-Dist: click>=8.1.7
 Requires-Dist: dynaconf>=3.2.6
@@ -23,20 +23,19 @@ Requires-Dist: toml>=0.10.2
 Requires-Dist: uvicorn>=0.32.1
 Description-Content-Type: text/markdown
 
-# Pocket 👛
+# Hyperpocket 👛
 
-Pocket is where tools belong. Power your agent up with a pocket of tools. 👛
+Hyperpocket is where tools belong. Power your agent up with a pocket of tools. 👛
 
 <figure>
-<img src="image.png" alt="4d-pocket" width="200"/>
-<figcaption>© Doraemon</figcaption>
+<img src="../../logo.png" alt="hyperpocket" width="200"/>
 </figure>
 
 ## Introduction
 
-Pocket is a tool that allows you to easily use tool and auth for agents on your machine.
+Hyperpocket is a tool that allows you to easily use tool and auth for agents on your machine.
 
-**_Start fast._** Just install Pocket and use it. We know you don't have time to authenticate to our server.
+**_Start fast._** Just install Hyperpocket and use it. We know you don't have time to authenticate to our server.
 
 **_Go securely._** Not like others, you are the only one who knows your secret tokens. We do NOT. All of your secret
 tokens belong to your infrastructure, not ours.
@@ -47,11 +46,6 @@ with the dependency spaghetti.
 
 **_Battery Included_** You can use popular tools and authentication providers out-of-the-box.
 
-<figure>
-<img src="pocket1.png" alt="pocket-flow" width="400"/>
-<figcaption></figcaption>
-</figure>
-
 ## Installation
 
 1. install hyperpocket
@@ -104,7 +98,7 @@ llm_tool_binding.invoke(...)
 
 There are two kinds of auth process, one is using system auth(developer api key) and the other is using end user auth.
 
-Pocket provides way to use end user auth easily.
+Hyperpocket provides way to use end user auth easily.
 (Of course, you can also just set your STRIPE_API_KEY when using Stripe API related tools)
 
 - Supported methods
@@ -218,12 +212,8 @@ Assistance: Here are the recent 10 messages.
 
 ### Config
 
-Running `pocket config init` will create your config file in `$HOME/.pocket/settings.toml`
-
 The `settings.toml` looks as follows.
 
-TODO: Add `secrets.toml`.
-
 ```toml
 log_level = "debug"
 internal_server_port = "8000" # optional, default is 8000
@@ -265,7 +255,7 @@ client_secret = ""  # your github client secret
 - While creating your github OAuth app, configuring your app's `Authorization callback URL` is different for your
   development environment and production environment.
   - For development environment, you can use `http://localhost:8000/auth/github/callback`
-    - **Note**: Default port for pocket dev server is `8000`. If you are using a different port, make sure to
+    - **Note**: Default port for hyperpocket dev server is `8000`. If you are using a different port, make sure to
       replace `8000` with your actual port number.
   - For production environment, you can use `https://yourdomain.com/auth/github/callback`
     - **Note**: Make sure to replace `yourdomain.com` with your actual domain name that this app will be hosted on.

{hyperpocket-0.1.8 → hyperpocket-0.1.9}/README.md

@@ -1,17 +1,16 @@
-# Pocket 👛
+# Hyperpocket 👛
 
-Pocket is where tools belong. Power your agent up with a pocket of tools. 👛
+Hyperpocket is where tools belong. Power your agent up with a pocket of tools. 👛
 
 <figure>
-<img src="image.png" alt="4d-pocket" width="200"/>
-<figcaption>© Doraemon</figcaption>
+<img src="../../logo.png" alt="hyperpocket" width="200"/>
 </figure>
 
 ## Introduction
 
-Pocket is a tool that allows you to easily use tool and auth for agents on your machine.
+Hyperpocket is a tool that allows you to easily use tool and auth for agents on your machine.
 
-**_Start fast._** Just install Pocket and use it. We know you don't have time to authenticate to our server.
+**_Start fast._** Just install Hyperpocket and use it. We know you don't have time to authenticate to our server.
 
 **_Go securely._** Not like others, you are the only one who knows your secret tokens. We do NOT. All of your secret
 tokens belong to your infrastructure, not ours.
@@ -22,11 +21,6 @@ with the dependency spaghetti.
 
 **_Battery Included_** You can use popular tools and authentication providers out-of-the-box.
 
-<figure>
-<img src="pocket1.png" alt="pocket-flow" width="400"/>
-<figcaption></figcaption>
-</figure>
-
 ## Installation
 
 1. install hyperpocket
@@ -79,7 +73,7 @@ llm_tool_binding.invoke(...)
 
 There are two kinds of auth process, one is using system auth(developer api key) and the other is using end user auth.
 
-Pocket provides way to use end user auth easily.
+Hyperpocket provides way to use end user auth easily.
 (Of course, you can also just set your STRIPE_API_KEY when using Stripe API related tools)
 
 - Supported methods
@@ -193,12 +187,8 @@ Assistance: Here are the recent 10 messages.
 
 ### Config
 
-Running `pocket config init` will create your config file in `$HOME/.pocket/settings.toml`
-
 The `settings.toml` looks as follows.
 
-TODO: Add `secrets.toml`.
-
 ```toml
 log_level = "debug"
 internal_server_port = "8000" # optional, default is 8000
@@ -240,7 +230,7 @@ client_secret = ""  # your github client secret
 - While creating your github OAuth app, configuring your app's `Authorization callback URL` is different for your
   development environment and production environment.
   - For development environment, you can use `http://localhost:8000/auth/github/callback`
-    - **Note**: Default port for pocket dev server is `8000`. If you are using a different port, make sure to
+    - **Note**: Default port for hyperpocket dev server is `8000`. If you are using a different port, make sure to
       replace `8000` with your actual port number.
   - For production environment, you can use `https://yourdomain.com/auth/github/callback`
     - **Note**: Make sure to replace `yourdomain.com` with your actual domain name that this app will be hosted on.

{hyperpocket-0.1.8 → hyperpocket-0.1.9}/hyperpocket/config/settings.py

@@ -7,18 +7,22 @@ from pydantic import BaseModel, Field
 from hyperpocket.config.auth import AuthConfig, DefaultAuthConfig
 from hyperpocket.config.session import DefaultSessionConfig, SessionConfig
 
-pocket_root = Path.home() / ".pocket"
-if not pocket_root.exists():
-    os.makedirs(pocket_root)
-settings_path = pocket_root / "settings.toml"
+POCKET_ROOT = Path.home() / ".pocket"
+SETTING_ROOT = Path.cwd()
+
+
+settings_path = SETTING_ROOT / "settings.toml"
 if not settings_path.exists():
     with open(settings_path, "w"):
         pass
-secret_path = pocket_root / ".secrets.toml"
+
+secret_path = SETTING_ROOT / ".secrets.toml"
 if not secret_path.exists():
     with open(secret_path, "w"):
         pass
-toolpkg_path = pocket_root / "toolpkg"
+
+
+toolpkg_path = POCKET_ROOT / "toolpkg"
 if not toolpkg_path.exists():
     os.makedirs(toolpkg_path)
 
@@ -50,9 +54,9 @@ class Config(BaseModel):
 
     @property
     def public_base_url(self):
-        if self.public_server_protocol == 'https' and self.public_server_port == 443:
+        if self.public_server_protocol == "https" and self.public_server_port == 443:
             return f"{self.public_server_protocol}://{self.public_hostname}"
-        elif self.public_server_protocol == 'http' and self.public_server_port == 80:
+        elif self.public_server_protocol == "http" and self.public_server_port == 80:
             return f"{self.public_server_protocol}://{self.public_hostname}"
         return f"{self.public_server_protocol}://{self.public_hostname}:{self.public_server_port}"
 

{hyperpocket-0.1.8 → hyperpocket-0.1.9}/hyperpocket/pocket_core.py

@@ -38,8 +38,10 @@ class PocketCore:
                     lock = LocalLock(tool_like)
                     req = WasmToolRequest(lock, "")
                 else:
-                    lock = GitLock(repository_url=tool_like, git_ref='HEAD')
-                    req = WasmToolRequest(lock, "")
+                    base_repo_url, git_ref, rel_path = GitLock.parsing_repo_url(repo_url=tool_like)
+                    lock = GitLock(repository_url=base_repo_url, git_ref=git_ref)
+                    req = WasmToolRequest(lock=lock, rel_path=rel_path, tool_vars={})
+
                 lockfile.add_lock(lock)
                 tool_likes.append(req)
             elif isinstance(tool_like, WasmToolRequest):

{hyperpocket-0.1.8 → hyperpocket-0.1.9}/hyperpocket/pocket_main.py

@@ -16,7 +16,9 @@ class Pocket(object):
                  tools: list[ToolLike],
                  auth: PocketAuth = None,
                  lockfile_path: Optional[str] = None,
-                 force_update: bool = False):
+                 force_update: bool = False,
+                 use_profile: bool = False):
+        self.use_profile = use_profile
 
         self.core = PocketCore(
             tools=tools,

{hyperpocket-0.1.8 → hyperpocket-0.1.9}/hyperpocket/repository/lock.py

@@ -1,7 +1,7 @@
 import abc
 import pathlib
 import shutil
-from typing import Optional
+from typing import Optional, Tuple
 
 import git
 from pydantic import BaseModel, Field
@@ -159,6 +159,57 @@ class GitLock(Lock):
                 break
         return new_sha
 
+    @classmethod
+    def get_git_branches(cls, repo_url):
+        ls_lists = git.cmd.Git().ls_remote(repo_url)
+
+        branches = {}
+        for line in ls_lists.split("\n"):
+            sha, ref = line.split("\t")
+            if ref.startswith("refs/heads/"):
+                branch_name = ref.replace("refs/heads/", "")
+                branches[branch_name] = sha
+
+        return branches
+
+    @classmethod
+    def parse_repo_url(cls, repo_url: str) -> Tuple[str, str, str]:
+        """
+        Parses a GitHub repository URL with optional branch and path information.
+
+        Returns:
+            Tuple[str, str, str]: base_repo, branch_name, directory_path
+        """
+        if not repo_url.startswith("https://github.com/"):
+            raise AttributeError("Only GitHub URLs are supported")
+
+        # Remove the base URL and split the path
+        repo_path = repo_url.removeprefix("https://github.com/")
+        repo_path_list = repo_path.split("/")
+
+        # Check if the URL contains 'tree' (indicating branch and sub-path information)
+        if "tree" not in repo_path_list:
+            # If no 'tree', return the full repository URL
+            return repo_url, "HEAD", ""
+
+        # Parse base repo URL and remaining path
+        tree_index = repo_path_list.index("tree")
+        base_repo = f"https://github.com/{'/'.join(repo_path_list[:tree_index])}"
+        sub_path = repo_path_list[tree_index + 1:]
+
+        # Fetch branch information
+        branches = cls.get_git_branches(base_repo)
+
+        # Find branch and sub-directory path
+        for idx in range(1, len(sub_path) + 1):
+            branch_name = "/".join(sub_path[:idx])
+            if branch_name in branches:
+                directory_path = "/".join(sub_path[idx:]) if idx < len(sub_path) else None
+                return base_repo, branch_name, directory_path
+
+        # If no valid branch is found, raise an error
+        raise ValueError("Branch not found in repository")
+
     def eject_to_path(self, dest_path: pathlib.Path, src_sub_path: str = None):
 
         # clone the git repository to the target path

{hyperpocket-0.1.8 → hyperpocket-0.1.9}/hyperpocket/server/server.py

@@ -136,11 +136,11 @@ class PocketServer(object):
         while True:
             if conn.poll():
                 op, uid, result, error = conn.recv()
-                if error:
-                    raise error
-
                 future = self.future_store[uid]
-                future.set_result(result)
+                if error:
+                    future.set_exception(error)
+                else:
+                    future.set_result(result)
                 break
             else:
                 await asyncio.sleep(0)
@@ -158,7 +158,7 @@ class PocketServer(object):
         self._set_mp_start_method()
 
         self.pipe = mp.Pipe()
-        self.process = mp.Process(target=self._run, args=(pocket_core,), daemon=True)
+        self.process = mp.Process(target=self._run, args=(pocket_core,))
         self.process.start()
 
     def _run(self, pocket_core):
@@ -185,9 +185,9 @@ class PocketServer(object):
         from hyperpocket.server.proxy import _generate_ssl_certificates
         from hyperpocket.server.proxy import https_proxy_app
 
-        from hyperpocket.config.settings import pocket_root
-        ssl_keypath = pocket_root / "callback_server.key"
-        ssl_certpath = pocket_root / "callback_server.crt"
+        from hyperpocket.config.settings import POCKET_ROOT
+        ssl_keypath = POCKET_ROOT / "callback_server.key"
+        ssl_certpath = POCKET_ROOT / "callback_server.crt"
 
         if not ssl_keypath.exists() or not ssl_certpath.exists():
             _generate_ssl_certificates(ssl_keypath, ssl_certpath)

{hyperpocket-0.1.8 → hyperpocket-0.1.9}/hyperpocket/tool/function/tool.py

@@ -1,11 +1,9 @@
 import asyncio
 import copy
 import inspect
-import pathlib
 from typing import Any, Coroutine
 from typing import Callable, Optional
 
-import toml
 from pydantic import BaseModel
 
 from hyperpocket.tool.tool import Tool, ToolAuth
@@ -47,32 +45,37 @@ class FunctionTool(Tool):
         _kwargs = copy.deepcopy(kwargs)
 
         # make body args to model
-        schema_model = self.schema_model()
-        model = schema_model(body=_kwargs["body"])
+        schema_model = self.schema_model(use_profile=False)
+        model = schema_model(**_kwargs["body"])
         _kwargs.pop("body")
 
         # body model to dict
-        args = self.model_to_kwargs(model.body)
+        args = self.model_to_kwargs(model)
 
         # binding args
         binding_args = {}
-        sig = inspect.signature(self.func)
-        for param_name, param in sig.parameters.items():
-            if param_name not in args:
-                continue
+        if self.func.__dict__.get("__model__") is not None:
+            # when a function signature is not inferrable from the function itself
+            binding_args = args.copy()
+            binding_args |= _kwargs.get("envs", {}) | self.tool_vars
+        else:
+            sig = inspect.signature(self.func)
+            for param_name, param in sig.parameters.items():
+                if param_name not in args:
+                    continue
 
-            if param.kind == param.VAR_KEYWORD:
-                # var keyword args should be passed by plain dict
-                binding_args |= args[param_name]
-                binding_args |= _kwargs.get("envs", {}) | self.tool_vars
+                if param.kind == param.VAR_KEYWORD:
+                    # var keyword args should be passed by plain dict
+                    binding_args |= args[param_name]
+                    binding_args |= _kwargs.get("envs", {}) | self.tool_vars
 
-                if "envs" in _kwargs:
-                    _kwargs.pop("envs")
+                    if "envs" in _kwargs:
+                        _kwargs.pop("envs")
 
-                binding_args |= _kwargs  # add other kwargs
-                continue
+                    binding_args |= _kwargs  # add other kwargs
+                    continue
 
-            binding_args[param_name] = args[param_name]
+                binding_args[param_name] = args[param_name]
 
         return binding_args
 
@@ -113,7 +116,7 @@ class FunctionTool(Tool):
             func=func,
             afunc=afunc,
             name=func.__name__,
-            description=model.__doc__,
+            description=func.__doc__ if func.__doc__ is not None else "",
             argument_json_schema=argument_json_schema,
             auth=auth,
             default_tool_vars=tool_vars
@@ -123,10 +126,16 @@ class FunctionTool(Tool):
     def from_dock(
         cls,
         dock: list[Callable[..., str]],
+        tool_vars: Optional[dict[str, str]] = None,
     ) -> list["FunctionTool"]:
+        if tool_vars is None:
+            tool_vars = dict()
         tools = []
         for func in dock:
-            model = function_to_model(func)
+            if (_model := func.__dict__.get("__model__")) is not None:
+                model = _model
+            else:
+                model = function_to_model(func)
             argument_json_schema = flatten_json_schema(model.model_json_schema())
             if not callable(func):
                 raise ValueError(f"Dock element should be a list of functions, but found {func}")
@@ -142,6 +151,7 @@ class FunctionTool(Tool):
                     description=func.__doc__,
                     argument_json_schema=argument_json_schema,
                     auth=auth,
+                    default_tool_vars=(tool_vars | func.__dict__.get("__vars__", {})),
                 ))
             else:
                 tools.append(cls(
@@ -151,22 +161,6 @@ class FunctionTool(Tool):
                     description=func.__doc__,
                     argument_json_schema=argument_json_schema,
                     auth=auth,
+                    default_tool_vars=(tool_vars | func.__dict__.get("__vars__", {})),
                 ))
         return tools
-        
-    @classmethod
-    def _get_tool_vars_from_config(cls, func: Callable) -> dict:
-        print(func.__name__)
-        tool_path = inspect.getfile(func)
-        print(tool_path)
-        tool_parent = "/".join(tool_path.split("/")[:-1])
-        tool_config_path = pathlib.Path(tool_parent) / "config.toml"
-        with tool_config_path.open("r") as f:
-            tool_config = toml.load(f)
-            tool_vars = tool_config.get("tool_var")
-            if not tool_vars:
-                return 
-            tool_vars_dict = {}
-            for key, value in tool_vars.items():
-                tool_vars_dict[key] = value
-            return tool_vars_dict

{hyperpocket-0.1.8 → hyperpocket-0.1.9}/hyperpocket/tool/tool.py

@@ -1,13 +1,11 @@
 import abc
-import pathlib
-
-import toml
 from typing import Optional, Type, Callable
 
 from pydantic import BaseModel, Field
 
 from hyperpocket.auth.provider import AuthProvider
 from hyperpocket.config.logger import pocket_logger
+from hyperpocket.prompts import pocket_extended_tool_description
 from hyperpocket.util.json_schema_to_model import json_schema_to_model
 
 
@@ -36,7 +34,7 @@ class ToolRequest(abc.ABC):
     @abc.abstractmethod
     def __str__(self):
         raise NotImplementedError
-    
+
     def add_postprocessing(self, postprocessing: Callable):
         if self.postprocessings is None:
             self.postprocessings = [postprocessing]
@@ -67,9 +65,11 @@ class Tool(BaseModel, abc.ABC):
     description: str = Field(description="tool description")
     argument_json_schema: Optional[dict] = Field(default=None, description="tool argument json schema")
     auth: Optional[ToolAuth] = Field(default=None, description="authentication information to invoke tool")
-    postprocessings: Optional[list[Callable]] = Field(default=None, description="postprocessing functions after tool is invoked")
+    postprocessings: Optional[list[Callable]] = Field(default=None,
+                                                      description="postprocessing functions after tool is invoked")
     default_tool_vars: dict[str, str] = Field(default_factory=dict, description="default tool variables")
     overridden_tool_vars: dict[str, str] = Field(default_factory=dict, description="overridden tool variables")
+    use_profile: bool = False
 
     @abc.abstractmethod
     def invoke(self, **kwargs) -> str:
@@ -84,17 +84,23 @@ class Tool(BaseModel, abc.ABC):
         """
         raise NotImplementedError()
 
-    def schema_model(self) -> Optional[Type[BaseModel]]:
+    def schema_model(self, use_profile: bool = False) -> Optional[Type[BaseModel]]:
         """
         Returns a schema_model that wraps the existing argument_json_schema
         to include profile and thread_id as arguments when the tool is invoked
         """
-        return self._get_schema_model(self.name, self.argument_json_schema)
-    
+        return self._get_schema_model(self.name, self.argument_json_schema, use_profile=use_profile)
+
+    def get_description(self, use_profile: bool = False) -> str:
+        if use_profile:
+            return pocket_extended_tool_description(self.description)
+        else:
+            return self.description
+
     def override_tool_variables(self, override_vars: dict[str, str]) -> 'Tool':
         self.overridden_tool_vars = override_vars
         return self
-    
+
     @property
     def tool_vars(self) -> dict[str, str]:
         return self.default_tool_vars | self.overridden_tool_vars
@@ -107,37 +113,40 @@ class Tool(BaseModel, abc.ABC):
         raise ValueError('Unknown tool request type')
 
     @classmethod
-    def _get_schema_model(cls, name: str, json_schema: Optional[dict]) -> Optional[Type[BaseModel]]:
+    def _get_schema_model(cls, name: str, json_schema: Optional[dict], use_profile: bool) -> Optional[Type[BaseModel]]:
         try:
             if not json_schema:
                 pocket_logger.info(f"{name} tool's json_schema is none.")
                 return None
             if 'description' not in json_schema:
                 json_schema['description'] = 'The argument of the tool.'
-            extended_schema = {
-                'title': name,
-                'type': 'object',
-                'properties': {
-                    'thread_id': {
-                        'type': 'string',
-                        'default': 'default',
-                        'description': 'The ID of the chat thread where the tool is invoked. Omitted when unknown.',
-                    },
-                    'profile': {
-                        'type': 'string',
-                        'default': 'default',
-                        'description': '''The profile of the user invoking the tool. Inferred from user's messages.
-                        Users can request tools to be invoked in specific personas, which is called a profile.
-                        If the user's profile name can be inferred from the query, pass it as a string in the 'profile'
-                        JSON property. Omitted when unknown.''',
+
+            if use_profile:
+                json_schema = {
+                    'title': name,
+                    'type': 'object',
+                    'properties': {
+                        'thread_id': {
+                            'type': 'string',
+                            'default': 'default',
+                            'description': 'The ID of the chat thread where the tool is invoked. Omitted when unknown.',
+                        },
+                        'profile': {
+                            'type': 'string',
+                            'default': 'default',
+                            'description': '''The profile of the user invoking the tool. Inferred from user's messages.
+                            Users can request tools to be invoked in specific personas, which is called a profile.
+                            If the user's profile name can be inferred from the query, pass it as a string in the 'profile'
+                            JSON property. Omitted when unknown.''',
+                        },
+                        'body': json_schema
                     },
-                    'body': json_schema
-                },
-                'required': [
-                    'body',
-                ]
-            }
-            model = json_schema_to_model(extended_schema, name)
+                    'required': [
+                        'body',
+                    ]
+                }
+
+            model = json_schema_to_model(json_schema, name)
             return model
         except Exception as e:
             pocket_logger.warning(f"failed to get tool({name}) schema model. error : {e}")

{hyperpocket-0.1.8 → hyperpocket-0.1.9}/hyperpocket/tool/wasm/browser.py

@@ -1,4 +1,5 @@
 import asyncio
+import os
 
 from playwright.async_api import async_playwright, Page, Playwright, BrowserContext, Route
 
@@ -13,15 +14,9 @@ class InvokerBrowser(object):
         raise RuntimeError("Use InvokerBrowser.get_instance() instead")
 
     async def _async_init(self):
-        # false only in dev
-        # TODO(moon.dev) : load from config by environment
-        import os
-        pocket_env = os.getenv("POCKET_ENV", "DEVELOPMENT")
-        is_headless = False if pocket_env == "DEVELOPMENT" else True
-
         self.playwright = await async_playwright().start()
         self.browser_context = await self.playwright.chromium.launch_persistent_context(
-            headless=is_headless,
+            headless=True,
             args=[
                 '--disable-web-security=True',
             ],

{hyperpocket-0.1.8 → hyperpocket-0.1.9}/hyperpocket/util/json_schema_to_model.py

@@ -70,6 +70,8 @@ def _convert_to_python_type(json_type, model_name, property_schema):
         field_type = str
     elif json_type == "boolean":
         field_type = bool
+    elif json_type == "number":
+        field_type = float
     elif json_type == "none":
         field_type = type(None)
     elif json_type == "object":

{hyperpocket-0.1.8 → hyperpocket-0.1.9}/pyproject.toml

@@ -1,8 +1,8 @@
 [project]
 name = "hyperpocket"
-version = "0.1.8"
+version = "0.1.9"
 description = "Building AI agent with hyperpocket tool in a flash"
-authors = [{ name = "VESSL AI Devs", email = "dev@vessl.ai" }]
+authors = [{ name = "Hyperpocket Team", email = "hyperpocket@vessl.ai" }]
 requires-python = ">=3.10"
 readme = "README.md"
 dependencies = [
@@ -31,7 +31,11 @@ Repository = "https://github.com/vessl-ai/hyperpocket"
 hyperpocket = "hyperpocket.cli.__main__:cli"
 
 [dependency-groups]
-dev = ["pytest>=8.3.4", "ruff>=0.8.6"]
+dev = [
+    "pytest>=8.3.4",
+    "pytest-cov>=6.0.0",
+    "ruff>=0.8.6",
+]
 
 [build-system]
 requires = ["hatchling"]