AtherisLiteLLM 0.2.5__tar.gz

atherislitellm-0.2.5/AtherisLiteLLM.egg-info/PKG-INFO

@@ -0,0 +1,50 @@
+Metadata-Version: 2.4
+Name: AtherisLiteLLM
+Version: 0.2.5
+Summary: AI-powered Python fuzzer using LiteLLM and Atheris to automatically generate and execute fuzzing harnesses.
+Author-email: Mario Marku <mariomarku7@gmail.com>
+License-Expression: GPL-3.0-or-later
+Project-URL: Homepage, https://github.com/mariobx
+Project-URL: Repository, https://github.com/mariobx/AtherisLiteLLM
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: litellm>=1.0.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: atheris>=2.3.0
+Requires-Dist: radon>=5.0.0
+Requires-Dist: requests>=2.31.0
+Dynamic: license-file
+
+## AtherisLiteLLM:
+This project creates a LLM-assisted Python fuzzing harness generator designed to leverage large language models via LiteLLM to automatically build fuzzing harnesses for target Python functions and classes. It uses Google’s Atheris fuzzing engine to dynamically generate and test code, with the aim of uncovering bugs or vulnerabilities in software.
+
+# Usage:
+  atherislitellm \
+    --src-dir /path/to/code \
+    --output-dir /path/to/logs \
+    --model google/gemini-1.5-flash \
+    --prompts-path /path/to/prompts.yaml \
+    --prompt base \
+    --api-key your_api_key_here (optional if env var is set) \
+    --extra-model-prompts project=my-project \
+    --debug \
+    --smell
+
+# Arguments:
+  - `-s`, `--src-dir`: Path to the Python source directory to fuzz.
+  - `-o`, `--output-dir`: Where to store crash logs and generated harnesses.
+  - `-m`, `--model`: LiteLLM model string (e.g., `gemini/gemini-1.5-flash`, `openai/gpt-4`).
+  - `-pp`, `--prompts-path`: Path to `prompts.yaml` config file.
+  - `-p`, `--prompt`: Prompt ID from `prompts.yaml` to use (default: `base`).
+  - `-k`, `--api-key`: API key string (optional if environment variable is set).
+  - `-e`, `--extra-mode-prompts`: Extra vendor-specific parameters as `key=value` pairs.
+  - `-d`, `--debug`: Enable debug/verbose mode.
+  - `-sm`, `--smell`: Enable code smell filtering via Radon.
+
+# Workflow:
+  1. Resolve API key (environment variable or raw string) and verify model via LiteLLM.
+  2. Discover .py files; parse target functions and classes.
+  3. (Optional) Filter by maintainability index using Radon.
+  4. Build prompt with Atheris docs + target code; send to the LLM via LiteLLM.
+  5. Save generated harnesses into a timestamped run directory.

atherislitellm-0.2.5/AtherisLiteLLM.egg-info/SOURCES.txt

@@ -0,0 +1,24 @@
+LICENSE
+README.md
+pyproject.toml
+AtherisLiteLLM.egg-info/PKG-INFO
+AtherisLiteLLM.egg-info/SOURCES.txt
+AtherisLiteLLM.egg-info/dependency_links.txt
+AtherisLiteLLM.egg-info/entry_points.txt
+AtherisLiteLLM.egg-info/requires.txt
+AtherisLiteLLM.egg-info/top_level.txt
+ai_fuzzer/__init__.py
+ai_fuzzer/cli.py
+ai_fuzzer/atherislitellm/run.py
+ai_fuzzer/atherislitellm/fetch/__init__.py
+ai_fuzzer/atherislitellm/fetch/fetch_docs.py
+ai_fuzzer/atherislitellm/llm/__init__.py
+ai_fuzzer/atherislitellm/llm/llm_requests.py
+ai_fuzzer/atherislitellm/logger/__init__.py
+ai_fuzzer/atherislitellm/logger/logs.py
+ai_fuzzer/atherislitellm/parsing/__init__.py
+ai_fuzzer/atherislitellm/parsing/function_parser.py
+ai_fuzzer/atherislitellm/sandbox/__init__.py
+ai_fuzzer/atherislitellm/sandbox/sandbox.py
+ai_fuzzer/atherislitellm/smell/__init__.py
+ai_fuzzer/atherislitellm/smell/smell.py

atherislitellm-0.2.5/AtherisLiteLLM.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

atherislitellm-0.2.5/AtherisLiteLLM.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+atherislitellm = ai_fuzzer.cli:main

atherislitellm-0.2.5/AtherisLiteLLM.egg-info/requires.txt

@@ -0,0 +1,5 @@
+litellm>=1.0.0
+pyyaml>=6.0
+atheris>=2.3.0
+radon>=5.0.0
+requests>=2.31.0

atherislitellm-0.2.5/AtherisLiteLLM.egg-info/top_level.txt

@@ -0,0 +1 @@
+ai_fuzzer

atherislitellm-0.2.5/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Mario Marku
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

atherislitellm-0.2.5/PKG-INFO

@@ -0,0 +1,50 @@
+Metadata-Version: 2.4
+Name: AtherisLiteLLM
+Version: 0.2.5
+Summary: AI-powered Python fuzzer using LiteLLM and Atheris to automatically generate and execute fuzzing harnesses.
+Author-email: Mario Marku <mariomarku7@gmail.com>
+License-Expression: GPL-3.0-or-later
+Project-URL: Homepage, https://github.com/mariobx
+Project-URL: Repository, https://github.com/mariobx/AtherisLiteLLM
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: litellm>=1.0.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: atheris>=2.3.0
+Requires-Dist: radon>=5.0.0
+Requires-Dist: requests>=2.31.0
+Dynamic: license-file
+
+## AtherisLiteLLM:
+This project creates a LLM-assisted Python fuzzing harness generator designed to leverage large language models via LiteLLM to automatically build fuzzing harnesses for target Python functions and classes. It uses Google’s Atheris fuzzing engine to dynamically generate and test code, with the aim of uncovering bugs or vulnerabilities in software.
+
+# Usage:
+  atherislitellm \
+    --src-dir /path/to/code \
+    --output-dir /path/to/logs \
+    --model google/gemini-1.5-flash \
+    --prompts-path /path/to/prompts.yaml \
+    --prompt base \
+    --api-key your_api_key_here (optional if env var is set) \
+    --extra-model-prompts project=my-project \
+    --debug \
+    --smell
+
+# Arguments:
+  - `-s`, `--src-dir`: Path to the Python source directory to fuzz.
+  - `-o`, `--output-dir`: Where to store crash logs and generated harnesses.
+  - `-m`, `--model`: LiteLLM model string (e.g., `gemini/gemini-1.5-flash`, `openai/gpt-4`).
+  - `-pp`, `--prompts-path`: Path to `prompts.yaml` config file.
+  - `-p`, `--prompt`: Prompt ID from `prompts.yaml` to use (default: `base`).
+  - `-k`, `--api-key`: API key string (optional if environment variable is set).
+  - `-e`, `--extra-mode-prompts`: Extra vendor-specific parameters as `key=value` pairs.
+  - `-d`, `--debug`: Enable debug/verbose mode.
+  - `-sm`, `--smell`: Enable code smell filtering via Radon.
+
+# Workflow:
+  1. Resolve API key (environment variable or raw string) and verify model via LiteLLM.
+  2. Discover .py files; parse target functions and classes.
+  3. (Optional) Filter by maintainability index using Radon.
+  4. Build prompt with Atheris docs + target code; send to the LLM via LiteLLM.
+  5. Save generated harnesses into a timestamped run directory.

atherislitellm-0.2.5/README.md

@@ -0,0 +1,32 @@
+## AtherisLiteLLM:
+This project creates a LLM-assisted Python fuzzing harness generator designed to leverage large language models via LiteLLM to automatically build fuzzing harnesses for target Python functions and classes. It uses Google’s Atheris fuzzing engine to dynamically generate and test code, with the aim of uncovering bugs or vulnerabilities in software.
+
+# Usage:
+  atherislitellm \
+    --src-dir /path/to/code \
+    --output-dir /path/to/logs \
+    --model google/gemini-1.5-flash \
+    --prompts-path /path/to/prompts.yaml \
+    --prompt base \
+    --api-key your_api_key_here (optional if env var is set) \
+    --extra-model-prompts project=my-project \
+    --debug \
+    --smell
+
+# Arguments:
+  - `-s`, `--src-dir`: Path to the Python source directory to fuzz.
+  - `-o`, `--output-dir`: Where to store crash logs and generated harnesses.
+  - `-m`, `--model`: LiteLLM model string (e.g., `gemini/gemini-1.5-flash`, `openai/gpt-4`).
+  - `-pp`, `--prompts-path`: Path to `prompts.yaml` config file.
+  - `-p`, `--prompt`: Prompt ID from `prompts.yaml` to use (default: `base`).
+  - `-k`, `--api-key`: API key string (optional if environment variable is set).
+  - `-e`, `--extra-mode-prompts`: Extra vendor-specific parameters as `key=value` pairs.
+  - `-d`, `--debug`: Enable debug/verbose mode.
+  - `-sm`, `--smell`: Enable code smell filtering via Radon.
+
+# Workflow:
+  1. Resolve API key (environment variable or raw string) and verify model via LiteLLM.
+  2. Discover .py files; parse target functions and classes.
+  3. (Optional) Filter by maintainability index using Radon.
+  4. Build prompt with Atheris docs + target code; send to the LLM via LiteLLM.
+  5. Save generated harnesses into a timestamped run directory.

atherislitellm-0.2.5/ai_fuzzer/atherislitellm/fetch/fetch_docs.py

@@ -0,0 +1,71 @@
+import re
+import requests
+import time
+from ai_fuzzer.atherislitellm.logger.logs import log
+
+cache = {}
+
+def fetch_with_retry(url: str, max_tries: int = 5, debug: bool = False) -> str:
+    """Fetch URL with a simple retry mechanism."""
+    for i in range(max_tries):
+        try:
+            response = requests.get(url, timeout=10)
+            response.raise_for_status()
+            content = response.text
+            if content:
+                return content
+            log(f"Empty response from {url}, retrying...", debug)
+        except (requests.exceptions.RequestException, requests.exceptions.Timeout) as e:
+            log(f"Error fetching {url}: {e}. Retrying ({i+1}/{max_tries})...", debug)
+            if i < max_tries - 1:
+                time.sleep(2 ** i) # Exponential backoff
+    
+    raise requests.exceptions.RequestException(f"Failed to fetch {url} after {max_tries} attempts")
+
+def fetch_atheris_readme(debug: bool = False) -> str:
+    """Fetch and return Google's Atheris README as cleaned plain text."""
+    if "readme" in cache:
+        return cache["readme"]
+
+    url = "https://raw.githubusercontent.com/google/atheris/master/README.md"
+    content = fetch_with_retry(url, debug=debug)
+
+    content = re.sub(r'!\[.*?\]\(.*?\)', '', content)
+    content = re.sub(r'\[.*?\]\(https?:\/\/.*?\)', '', content)
+    content = re.sub(r'\n{3,}', '\n\n', content)
+    formatted = f"""
+==== START OF ATHERIS DOCUMENTATION ====
+
+This is the official README documentation for Google's Atheris fuzzing framework for Python.
+
+{content}
+
+==== END OF ATHERIS DOCUMENTATION ====
+"""
+    cache["readme"] = formatted
+    log("fetched atheris readme", debug)
+    return formatted
+
+def fetch_atheris_hooking_docs(debug: bool = False) -> str:
+    """Fetch and return Google's Atheris hooking docs as cleaned plain text."""
+    if "hooking" in cache:
+        return cache["hooking"]
+
+    url = "https://raw.githubusercontent.com/google/atheris/refs/heads/master/hooking.md"
+    content = fetch_with_retry(url, debug=debug)
+
+    content = re.sub(r'!\[.*?\]\(.*?\)', '', content)
+    content = re.sub(r'\[.*?\]\(https?:\/\/.*?\)', '', content)
+    content = re.sub(r'\n{3,}', '\n\n', content)
+    formatted = f"""
+==== START OF ATHERIS' HOOKING DOCUMENTATION ====
+
+This is the official README documentation for Google's Atheris fuzzing framework for Python.
+
+{content}
+
+==== END OF ATHERIS' HOOKING DOCUMENTATION ====
+"""
+    cache["hooking"] = formatted
+    log("fetched atheris hooking documentation", debug)
+    return formatted

atherislitellm-0.2.5/ai_fuzzer/atherislitellm/llm/llm_requests.py

@@ -0,0 +1,61 @@
+from pathlib import Path
+from typing import Optional, Tuple
+import yaml
+from ai_fuzzer.atherislitellm.fetch import fetch_docs
+import re
+from ai_fuzzer.atherislitellm.logger.logs import log
+import litellm
+
+def extract_code_blocks(text):
+    """Extract fenced code blocks from text and return them joined.
+
+    Finds all triple-backtick code fences (optionally with a language
+    tag) and returns their inner contents joined by two newlines. If
+    no code blocks are found, returns an empty string.
+    """
+    if not text:
+        return ""
+    pattern = r'```(?:[\w+-]*)\s*\n([\s\S]*?)```'
+    matches = re.findall(pattern, text)
+    return '\n\n'.join(matches)
+
+def load_prompt_data(prompt_id: str, yaml_path: Path, debug=False) -> Tuple[float, str, str]:
+    """Load prompt settings from a YAML file and return (temperature, description, template)."""
+    with open(yaml_path, "r", encoding="utf-8") as f:
+        all_prompts = yaml.safe_load(f)
+    if prompt_id not in all_prompts:
+        raise KeyError(f"Prompt ID '{prompt_id}' not found in {yaml_path}")
+    entry = all_prompts[prompt_id]
+    return float(entry["temperature"]), entry["description"], entry["template"]
+
+def format_prompt(template: str, target_func: str, debug=False) -> str:
+    """Fill the template with the target function and Atheris docs."""
+    doc_block = f"{fetch_docs.fetch_atheris_readme(debug)}\n\n{fetch_docs.fetch_atheris_hooking_docs(debug)}"
+    return template.replace("{{CODE}}", target_func).replace("{{DOCS}}", doc_block)
+
+def get_response(client: dict, prompt_id: str, target_func: str, yaml_path: Path, debug: bool = False, **kwargs) -> str | None:
+    """Prepare a prompt, call LLM via LiteLLM to generate content, and return the text."""
+    log("Preparing prompt and making a LiteLLM call...", debug)
+    
+    try:
+        temperature, _, template = load_prompt_data(prompt_id, yaml_path, debug)
+        full_prompt = format_prompt(template, target_func, debug)
+
+        # LiteLLM handles retries via num_retries
+        response = litellm.completion(
+            model=client["model"],
+            messages=[{"role": "user", "content": full_prompt}],
+            api_key=client["api_key"],
+            temperature=temperature,
+            num_retries=5,
+            **kwargs
+        )
+
+        content = getattr(getattr(getattr(response, "choices", [None])[0], "message", None), "content", None)
+        if not content:
+            log("Warning: Received empty content from model response.", True)
+        return content
+
+    except Exception as e:
+        log(f"Error during LLM completion: {e}", True)
+        return None

atherislitellm-0.2.5/ai_fuzzer/atherislitellm/logger/logs.py

@@ -0,0 +1,50 @@
+import os
+import sys
+import traceback
+import inspect
+from pathlib import Path
+from datetime import datetime
+
+_LOG_BASE: Path | None = None
+_LOG_FILE: Path | None = None
+
+def init_logger(base_path: str) -> None:
+    """Set up the log directory and log file under the given base path."""
+    global _LOG_BASE, _LOG_FILE
+    _LOG_BASE = Path(base_path)
+    log_dir = _LOG_BASE / "logs"
+    log_dir.mkdir(parents=True, exist_ok=True)
+    _LOG_FILE = log_dir / "log.log"
+
+def log(msg: str, echo: bool = False) -> None:
+    """Write a timestamped debug message to the log file (optionally echo)."""
+    if _LOG_FILE is None:
+        raise RuntimeError("Logger not initialized. Call init_logger(path) first.")
+
+    # caller frame
+    current = inspect.currentframe()
+    frame = current.f_back if current is not None else None
+    if frame is not None:
+        filename = Path(frame.f_code.co_filename).name
+        lineno = frame.f_lineno
+    else:
+        filename = "<unknown>"
+        lineno = 0
+
+    ts = datetime.now().strftime("%m/%d/%y %I:%M:%S%p")
+    line = f"{ts} --- DEBUG --- {filename}:{lineno} - {msg}\n"
+
+    # If called inside an exception handler, append traceback
+    exc_type, exc, tb = sys.exc_info()
+    if exc is not None and not isinstance(exc, SyntaxError):
+        line += "".join(traceback.format_exception(exc_type, exc, tb)) + "\n"
+    
+    try:
+        with _LOG_FILE.open("a", encoding="utf-8") as f:
+            f.write(line)
+        if echo:
+            sys.stdout.write(line)
+            sys.stdout.flush()
+    except Exception as e:
+        sys.stderr.write(f"[log_debug ERROR] {e}\n")
+        sys.stderr.flush()

atherislitellm-0.2.5/ai_fuzzer/atherislitellm/parsing/function_parser.py

@@ -0,0 +1,83 @@
+import os
+import ast
+from typing import List
+from pathlib import Path
+from ai_fuzzer.atherislitellm.logger.logs import log
+
+def is_virtualenv_dir(path, debug=False):
+    """
+    Returns True if the given directory looks like a Python virtual environment.
+    """
+    pyvenv_cfg = os.path.join(path, "pyvenv.cfg")
+    bin_python = os.path.join(path, "bin", "python")
+    scripts_python = os.path.join(path, "Scripts", "python.exe")
+    if os.path.isfile(pyvenv_cfg):
+        if os.path.isfile(bin_python) or os.path.isfile(scripts_python):
+            log(f"Found virtualenv at {path}, which we will ignore", debug)
+            return True
+    return False
+
+def get_python_file_paths(directory_path, debug=False):
+    """
+    Recursively get .py files, skipping virtual environments.
+    """
+    log(f"Walking directory {directory_path} (type: {type(directory_path)})", debug)
+    python_files: List[str] = []
+    for root, dirs, files in os.walk(directory_path):
+        dirs[:] = [d for d in dirs if not is_virtualenv_dir(os.path.join(root, d), debug)]
+        for file in files:
+            if file.endswith(".py"):
+                full_path = os.path.join(root, file)
+                python_files.append(full_path)
+                log(f"Found Python file: {full_path} (type: {type(full_path)})", debug)
+    return python_files
+
+def extract_functions(path: str | Path, debug=False) -> dict[str, str]:
+    """
+    Parses a Python file and extracts all functions as a dictionary mapping function names to source code strings.
+    """
+    path = Path(path)
+    if not path.is_file():
+        return {}
+
+    source_code = path.read_text(encoding="utf-8")
+    tree = ast.parse(source_code, filename=str(path))
+
+    # Iterate ONLY through the top-level nodes of the file
+    # This automatically excludes functions defined inside classes
+    functions = {}
+    for node in tree.body:
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            source = ast.get_source_segment(source_code, node)
+            if source:
+                functions[node.name] = source
+
+    log(f"Extracted {len(functions)} top-level function(s) from {path}", debug)
+    return functions
+
+def extract_classes(path: str | Path, debug=False):
+    path = Path(path)
+    if not path.is_file():
+        return {}, {}
+
+    source_code = path.read_text(encoding="utf-8")
+    tree = ast.parse(source_code)
+
+    classes_in_file = {}
+    functions_inside_classes = {}
+
+    for node in tree.body:
+        if isinstance(node, ast.ClassDef):
+            cls_name = node.name
+            cls_body = ast.get_source_segment(source_code, node)
+            classes_in_file[cls_name] = cls_body
+            methods = []
+            for item in node.body:
+                if isinstance(item, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                    method_source = ast.get_source_segment(source_code, item)
+                    methods.append((item.name, method_source))
+            
+            functions_inside_classes[cls_name] = methods
+
+    log(f"Extracted {len(classes_in_file)} class(es) from {path}", debug)
+    return classes_in_file, functions_inside_classes

atherislitellm-0.2.5/ai_fuzzer/atherislitellm/run.py

@@ -0,0 +1,141 @@
+from pathlib import Path
+from datetime import datetime
+from typing import Sequence, Dict
+import os
+from ai_fuzzer.atherislitellm.llm import llm_requests as atherisai
+from ai_fuzzer.atherislitellm.sandbox import sandbox
+from ai_fuzzer.atherislitellm.parsing import function_parser
+from ai_fuzzer.atherislitellm.smell.smell import code_smells
+from ai_fuzzer.atherislitellm.logger.logs import log
+
+def on_crash(output_dir: Path, data: list, debug: bool = False) -> None:
+    """Write a crash report file containing harness outputs and log the event."""
+
+    try:
+        log(f"Crash occurred, output directory: {output_dir}", debug)
+        with open(output_dir / "crash_report.txt", "w", encoding="utf-8") as f:
+            for i, contents in enumerate(data):
+                f.write(f"HARNESS {i+1}\n\n----\n\n{contents}\n\n----\n\n")
+    except (OSError, IOError, Exception) as e:
+        log(f"Failed to write crash report: {e}", debug)
+
+def make_run_dir(base: Path, debug=False) -> Path:
+    """Create and return a timestamped run directory under the given base path."""
+
+    timestamp = datetime.now().strftime("%m-%d-%y_%I-%M-%S%p").lower()
+    run_dir = base / f"run-{timestamp}"
+    run_dir.mkdir(parents=True, exist_ok=False)
+    log(f"Created run directory at: {run_dir}", debug)
+    return run_dir
+
+def retrieve_function_candidates(client: dict, path: Path, prompt_id: str, prompt_yaml_path: Path, output_dir: Path, run_dir: Path, debug: bool = False, smell: bool = False, **kwargs) -> dict[str, str]:
+    """Discover functions in the source path and generate test snippets via the LLM client."""
+
+    func_tests = {}
+    pyfiles = function_parser.get_python_file_paths(path, debug=debug)
+    if pyfiles:
+        log(f"Retrieved {len(pyfiles)} Python files from: {path}", debug)
+    for pyfile in pyfiles:
+        try:
+            funcs = function_parser.extract_functions(pyfile, debug=debug)
+            log(f"Found {len(funcs)} functions in {pyfile}", debug)
+            for func_name, func_body in funcs.items():
+                if smell:
+                    if not code_smells(python_code=func_body, debug=debug):
+                        continue
+                response = atherisai.get_response(
+                    client=client,
+                    prompt_id=prompt_id,
+                    target_func=func_body,
+                    yaml_path=prompt_yaml_path,
+                    debug=debug,
+                    **kwargs
+                )
+                block = atherisai.extract_code_blocks(response)
+                func_tests[func_name] = block
+                log(f"Generated test for function: {func_name}", debug)
+                
+                # Save immediately
+                sandbox.save_to_file(func_name, block, run_dir, debug=debug)
+        except Exception as e:
+                log(f"Error processing file: {e}", debug)
+                on_crash(output_dir, list(func_tests.values()), debug=debug)
+    return func_tests
+
+def retrieve_class_candidates(client: dict, path: Path, prompt_id: str, prompt_yaml_path: Path, output_dir: Path, run_dir: Path, debug: bool = False, smell: bool = False, **kwargs) -> dict[str, str]:
+    """Discover classes in the source path and generate test snippets via the LLM client."""
+
+    class_tests = {}
+    pyfiles = function_parser.get_python_file_paths(path, debug=debug)
+    if pyfiles:
+        log(f"Retrieved {len(pyfiles)} Python files from: {path}", debug)
+    for pyfile in pyfiles:
+        classes_in_file, functions_inside_classes = function_parser.extract_classes(pyfile, debug=debug)
+        log(f"Found {len(classes_in_file)} classes in {pyfile}", debug)
+        try:
+            for class_name, class_body in classes_in_file.items():
+                if smell:
+                    if not code_smells(python_code=class_body, debug=debug):
+                        continue
+                methods = functions_inside_classes.get(class_name, []) 
+                for function_name, function_body in methods:
+                    customized_target_prompt = (
+                        f"\n\n{class_body}\n\n"
+                        f"**FUZZING FOCUS**\n"
+                        f"Method Name: {function_name}\n"
+                        f"Method Body:\n{function_body}"
+                    )
+                    response = atherisai.get_response(
+                        client=client,
+                        prompt_id=prompt_id,
+                        target_func=customized_target_prompt,
+                        yaml_path=prompt_yaml_path,
+                        debug=debug,
+                        **kwargs
+                    )
+                    block = atherisai.extract_code_blocks(response)
+                    key = f"{class_name}.{function_name}"
+                    class_tests[key] = block
+                    log(f"Generated test for class method: {key}", debug)
+                    
+                    # Save immediately
+                    sandbox.save_to_file(key, block, run_dir, debug=debug)
+        except Exception as e:
+            log(f"Error processing class: {e}", debug)
+            on_crash(output_dir, list(class_tests.values()), debug=debug)
+    return class_tests
+
+def save_harnesses(code_snippets: dict[str, str], run_dir: Path, debug: bool):
+    """Save generated harnesses into the provided run directory (Redundant but kept for compatibility)."""
+    if not code_snippets:
+        return
+    log(f"Saving {len(code_snippets)} harnesses to {run_dir}", debug)
+    for name, code in code_snippets.items():
+        if code:
+            sandbox.save_to_file(name, code, run_dir, debug=debug)
+
+def run(
+        source_dir: Path, output_dir: Path, prompt_id: str, prompt_yaml_path: Path, model: str, api: str, debug: bool, smell: bool, **kwargs
+) -> None:
+    """Coordinate test generation: create client, generate snippets, and save them immediately."""
+
+    log(f"run() called with source_dir={source_dir}, output_dir={output_dir}, model={model}, prompt_id={prompt_id}", debug)
+
+    client = {
+            "model": model.strip() if model else "",
+            "api_key": api.strip() if api else None,
+    }
+
+    # Ensure output_dir exists
+    output_dir.mkdir(parents=True, exist_ok=True)
+    run_dir = make_run_dir(output_dir, debug=debug)
+
+    log(f"Starting candidate retrieval for functions from {source_dir}", debug)
+    function_code_snippets = retrieve_function_candidates(client, source_dir, prompt_id, prompt_yaml_path, output_dir=output_dir, run_dir=run_dir, debug=debug, smell=smell, **kwargs)
+    log(f"Found {len(function_code_snippets)} function snippets", debug)
+
+    log(f"Starting candidate retrieval for classes from {source_dir}", debug)
+    class_code_snippets = retrieve_class_candidates(client, source_dir, prompt_id, prompt_yaml_path, output_dir=output_dir, run_dir=run_dir, debug=debug, smell=smell, **kwargs)
+    log(f"Found {len(class_code_snippets)} class snippets", debug)
+
+    log(f"Run completed. All harnesses saved in {run_dir}", debug)

atherislitellm-0.2.5/ai_fuzzer/atherislitellm/sandbox/sandbox.py

@@ -0,0 +1,26 @@
+import subprocess
+from pathlib import Path
+import tempfile
+import os
+from textwrap import dedent
+import venv
+from ai_fuzzer.atherislitellm.logger.logs import log
+
+def save_to_file(name=None, text=None, path=None, debug=False):
+    """Save provided text to a timestamped Atheris harness file in path,
+    creating a subdirectory named after `name` and placing the file inside it.
+    """
+    if path is None:
+        raise ValueError("The 'path' argument must not be None.")
+
+    # Make subdirectory: <path>/<name>/
+    subdir = os.path.join(path, str(name))
+    os.makedirs(subdir, exist_ok=True)
+
+    # Write file inside the subdirectory
+    file_path = os.path.join(subdir, f'atheris_harness_for_(({name})).py')
+    with open(file_path, 'w', encoding='utf-8') as f:
+        f.write(text if text is not None else "")
+
+    log(f"Text length: {len(text) if text else 0}", debug)
+

atherislitellm-0.2.5/ai_fuzzer/atherislitellm/smell/smell.py

@@ -0,0 +1,18 @@
+from radon.metrics import mi_visit
+from ai_fuzzer.atherislitellm.logger.logs import log
+
+def code_smells(python_code: str, threshold: float = 65.0, debug: bool = False) -> bool:
+    """
+    Determines if the given Python code smells based on the Maintainability Index (MI).
+    Returns bool: True if the code smells, False otherwise.
+    """
+    results = mi_visit(python_code, True)
+    if not results:
+        return False
+
+    decision = results < threshold
+
+    action = "will fuzz" if decision else "will skip fuzzing"
+    log(f"MI score = {results} (threshold = {threshold}) → {action}", debug)
+
+    return decision

atherislitellm-0.2.5/ai_fuzzer/cli.py

@@ -0,0 +1,125 @@
+from pathlib import Path
+import argparse
+import os
+import sys
+import litellm
+from ai_fuzzer.atherislitellm.run import run
+from ai_fuzzer.atherislitellm.logger.logs import log, init_logger
+
+def resolve_api_key(arg_val: str | None, model: str, debug: bool = False) -> str | None:
+    """
+    Resolve API key from CLI or Environment.
+    If not found, use LiteLLM to tell the user which env var to set.
+    """
+    if arg_val:
+        log("Using API key provided via CLI", debug)
+        return arg_val.strip()
+
+    # Check LiteLLM environment requirements for the model
+    try:
+        check = litellm.validate_environment(model)
+        if check.get("keys_in_environment"):
+            log(f"Environment is valid for model '{model}'", debug)
+            return None # LiteLLM will pick it up from env
+        
+        missing = check.get("missing_keys", [])
+        if missing:
+            print(f"Error: Missing API key for model '{model}'.")
+            print("Please provide it via --api-key or set the following environment variable(s):")
+            for key in missing:
+                # Provide cross-platform instructions
+                if sys.platform == "win32":
+                    print(f"  set {key}=your_api_key_here")
+                else:
+                    print(f"  export {key}=your_api_key_here")
+            sys.exit(1)
+    except Exception as e:
+        log(f"Error validating environment with LiteLLM: {e}", debug)
+    
+    return None
+
+class ParseKwargs(argparse.Action):
+    def __call__(self, parser, namespace, values, option_string=None):
+        setattr(namespace, self.dest, dict())
+        for value in values:
+            if '=' in value:
+                key, val = value.split('=', 1)
+                getattr(namespace, self.dest)[key] = val
+            else:
+                log(f"Warning: Ignoring malformed extra prompt: {value}", True)
+
+def main():
+    """Parse CLI arguments and run the fuzzer."""
+    parser = argparse.ArgumentParser(description="AI-powered Python fuzzer with AtherisLiteLLM (LiteLLM + Atheris).")
+
+    parser.add_argument("-s", "--src-dir", type=Path, required=True,
+                        help="Path to the Python source directory to fuzz.")
+
+    parser.add_argument("-o", "--output-dir", type=Path, required=True,
+                        help="Where to store crash logs and generated harnesses.")
+
+    parser.add_argument("-pp", "--prompts-path", type=Path, required=True,
+                        help="Path to prompts.yaml config file.")
+
+    parser.add_argument("-p", "--prompt", default="base", required=True,
+                        help="Prompt ID from prompts.yaml to use (default: 'base')")
+
+    parser.add_argument("-m", "--model", type=str, required=True,
+                        help="LiteLLM model string (e.g., 'gemini/gemini-1.5-flash', 'openai/gpt-4').")
+
+    parser.add_argument("-k", "--api-key", type=str,
+                        help="API key string. If not provided, the tool will check environment variables.")
+
+    parser.add_argument("-e", "--extra-model-prompts", nargs='*', action=ParseKwargs,
+                        help="Extra vendor-specific parameters as key=value pairs (e.g., project=my-project).")
+
+    parser.add_argument("-d", "--verbose", "-v", "--debug", action="store_true",
+                        help="Enable debug/verbose mode.")
+
+    parser.add_argument("-sm", "--smell", action="store_true",
+                        help="Enable code smell filtering via Radon (Maintainability Index).")
+
+    args = parser.parse_args()
+
+    # Initialize logger early
+    init_logger(args.output_dir)
+
+    # Validate model
+    try:
+        litellm.get_llm_provider(args.model)
+    except Exception as e:
+        print(f"Error: '{args.model}' is not a recognized LiteLLM model. {str(e)}")
+        sys.exit(1)
+
+    # Resolve API Key
+    api_key = resolve_api_key(args.api_key, args.model, args.verbose)
+    if not api_key:
+        print(f"Error: No API key found for model '{args.model}'. Please provide one via -k or environment variables.")
+        sys.exit(1)
+
+    # Prepare extra parameters
+    extra_params = getattr(args, 'extra_model_prompts', {}) or {}
+    if extra_params:
+        log(f"Using extra model parameters: {list(extra_params.keys())}", args.verbose)
+
+    try:
+        run(
+            source_dir=args.src_dir,
+            output_dir=args.output_dir,
+            prompt_id=args.prompt,
+            prompt_yaml_path=args.prompts_path,
+            model=args.model,
+            api=api_key,
+            debug=args.verbose,
+            smell=args.smell,
+            **extra_params
+        )
+    except Exception as e:
+        import traceback
+        print(f"ERROR: {e}")
+        if args.verbose:
+            traceback.print_exc()
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

atherislitellm-0.2.5/pyproject.toml

@@ -0,0 +1,29 @@
+[project]
+name = "AtherisLiteLLM"
+version = "0.2.005"
+description = "AI-powered Python fuzzer using LiteLLM and Atheris to automatically generate and execute fuzzing harnesses."
+authors = [
+  { name="Mario Marku", email="mariomarku7@gmail.com" }
+]
+readme = "README.md"
+license = "GPL-3.0-or-later"
+requires-python = ">=3.11,"
+
+dependencies = [
+  "litellm>=1.0.0",
+  "pyyaml>=6.0",
+  "atheris>=2.3.0",
+  "radon>=5.0.0",
+  "requests>=2.31.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/mariobx"
+Repository = "https://github.com/mariobx/AtherisLiteLLM"
+
+[project.scripts]
+atherislitellm = "ai_fuzzer.cli:main"
+
+[build-system]
+requires = ["setuptools>=61", "wheel"]
+build-backend = "setuptools.build_meta"

atherislitellm-0.2.5/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+