merge diana's changes (and fixes) into development

.gitignore

@@ -11,3 +11,6 @@ src/hackingBuddyGPT.egg-info/
 build/
 dist/
 .coverage
+src/hackingBuddyGPT/usecases/web_api_testing/openapi_spec/
+src/hackingBuddyGPT/usecases/web_api_testing/converted_files/
+/src/hackingBuddyGPT/usecases/web_api_testing/utils/openapi_spec/

pyproject.toml

@@ -29,11 +29,14 @@ dependencies = [
 	'requests == 2.32.0',
 	'rich == 13.7.1',
 	'tiktoken == 0.6.0',
-	'instructor == 1.2.2',
+	'instructor == 1.3.5',
 	'PyYAML == 6.0.1',
 	'python-dotenv == 1.0.1',
 	'pypsexec == 0.3.0',
+	'pydantic == 2.8.2',
 	'openai == 1.28.0',
+	'spacy',
+	'BeautifulSoup4'
 ]
 
 [project.urls]

src/hackingBuddyGPT/capabilities/http_request.py

@@ -41,7 +41,16 @@ def __call__(self,
                  ) -> str:
         if body is not None and body_is_base64:
             body = base64.b64decode(body).decode()
-
+        if self.host[-1] != "/":
+            path = "/" + path
+        resp = self._client.request(
+            method,
+            self.host + path,
+            params=query,
+            data=body,
+            headers=headers,
+            allow_redirects=self.follow_redirects,
+        )
         try:
             resp = self._client.request(
                 method,

src/hackingBuddyGPT/capabilities/submit_http_method.py

@@ -0,0 +1,73 @@
+import base64
+from dataclasses import dataclass, field
+from typing import Set, Dict, Callable, Literal, Optional
+import inspect
+
+import requests
+from pydantic import create_model, BaseModel
+
+from . import Capability
+
+
+@dataclass
+class SubmitHTTPMethod(Capability):
+    http_methods_format: str
+    valid_http_methods: Set[str]
+    _client = requests.Session()
+    host: str
+    follow_redirects: bool = False
+
+
+    submitted_valid_http_methods: Set[str] = field(default_factory=set, init=False)
+
+    def describe(self) -> str:
+        return f"Submits a HTTP methods, which is the goal of all activities. The HTTP methods format is {self.http_methods_format}. If you find a flag following the that format, that you have not yet submitted, then the most important first step is to submit it, ignoring all other possibilities of further action"
+
+    def to_model(self) -> BaseModel:
+        """
+        Converts the parameters of the `__call__` function of the capability to a pydantic model, that can be used to
+        interface with an LLM using eg instructor or the openAI function calling API.
+        The model will have the same name as the capability class and will have the same fields as the `__call__`,
+        the `__call__` method can then be accessed by calling the `execute` method of the model.
+        """
+        sig = inspect.signature(self.__call__)
+        fields = {param: (param_info.annotation, ...) for param, param_info in sig.parameters.items()}
+        model_type = create_model(self.__class__.__name__, __doc__=self.describe(), **fields)
+
+        def execute(model):
+            m = model.dict()
+            return self(**m)
+
+        model_type.execute = execute
+
+        return model_type
+
+    def __call__(self, method: Literal["GET", "HEAD", "POST", "PUT", "DELETE", "OPTION", "PATCH"],
+                 path: str,
+                 query: Optional[str] = None,
+                 body: Optional[str] = None,
+                 body_is_base64: Optional[bool] = False,
+                 headers: Optional[Dict[str, str]] = None
+                 ) -> str:
+
+        if body is not None and body_is_base64:
+            body = base64.b64decode(body).decode()
+
+        resp = self._client.request(
+            method,
+            self.host + path,
+            params=query,
+            data=body,
+            headers=headers,
+            allow_redirects=self.follow_redirects,
+        )
+        try:
+            resp.raise_for_status()
+        except requests.exceptions.HTTPError as e:
+            return str(e)
+
+        headers = "\r\n".join(f"{k}: {v}" for k, v in resp.headers.items())
+
+        # turn the response into "plain text format" for responding to the prompt
+        return f"HTTP/1.1 {resp.status_code} {resp.reason}\r\n{headers}\r\n\r\n{resp.text}"""
+

src/hackingBuddyGPT/capabilities/yamlFile.py

@@ -0,0 +1,44 @@
+from dataclasses import dataclass, field
+from typing import Tuple, List
+
+import yaml
+
+from . import Capability
+
+@dataclass
+class YAMLFile(Capability):
+
+    def describe(self) -> str:
+        return "Takes a Yaml file and updates it with the given information"
+
+    def __call__(self, yaml_str: str) -> str:
+        """
+           Updates a YAML string based on provided inputs and returns the updated YAML string.
+
+           Args:
+           yaml_str (str): Original YAML content in string form.
+           updates (dict): A dictionary representing the updates to be applied.
+
+           Returns:
+           str: Updated YAML content as a string.
+           """
+        try:
+            # Load the YAML content from string
+            data = yaml.safe_load(yaml_str)
+
+            print(f'Updates:{yaml_str}')
+
+            # Apply updates from the updates dictionary
+            #for key, value in updates.items():
+            #    if key in data:
+            #        data[key] = value
+            #    else:
+            #        print(f"Warning: Key '{key}' not found in the original data. Adding new key.")
+            #        data[key] = value
+            #
+            ## Convert the updated dictionary back into a YAML string
+            #updated_yaml_str = yaml.safe_dump(data, sort_keys=False)
+            #return updated_yaml_str
+        except yaml.YAMLError as e:
+            print(f"Error processing YAML data: {e}")
+            return "None"

src/hackingBuddyGPT/usecases/base.py

@@ -156,6 +156,7 @@ def perform_round(self, turn: int):
 
 def use_case(description):
     def inner(cls):
+        cls = dataclass(cls)
         name = cls.__name__.removesuffix("UseCase")
         if name in use_cases:
             raise IndexError(f"Use case with name {name} already exists")