fuzzprep 0.1.0__py3-none-any.whl

fuzzprep/library_builder/workspace.py

@@ -0,0 +1,250 @@
+"""The project workspace: one directory layout, materialized once, verified, then shipped.
+
+`.fuzzprep/<project>/` is the project, not a scratch area translated into output later.
+It holds a real OSS-Fuzz project (`project.yaml`, `Dockerfile`, `build.sh`) plus the build and
+harness-compile scripts, and generation copies it verbatim, so what ships is what was
+verified, including any repair an agent applied.
+
+Both environments materialize the same layout. Only the oss-fuzz target builds an image from
+the Dockerfile here.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from fuzzprep.core.files import write_executable
+from fuzzprep.library_builder.build_parameters import BuildParameters
+from fuzzprep.library_builder.models import (
+    AnalysisResult,
+    AutotoolsSetup,
+    Language,
+    LinkConfiguration,
+)
+from fuzzprep.library_builder.scripts import (
+    HARNESS_SOURCE_DIR,
+    build_harness_script,
+    build_harnesses_script,
+    write_default_fuzzer,
+)
+
+_AUTOTOOLS_PACKAGES = ("autoconf", "automake", "libtool", "pkg-config")
+
+# ubuntu-24-04, not the Focal-based default tag: Focal's bear (2.4.3) mishandles the
+# `bear -- <command>` form exploration.py builds, passing `--` on as if it were the command.
+# Ubuntu 24.04 ships bear 3.x, which handles it.
+DEFAULT_BASE_IMAGE = "gcr.io/oss-fuzz-base/base-builder:ubuntu-24-04"
+
+# The one place this apt-get invocation text is spelled out. Shared with generation's
+# bear-stripping and with inject_apt_packages below.
+APT_INSTALL_PREFIX = "RUN apt-get update && apt-get install -y --no-install-recommends"
+
+# build.sh is what OSS-Fuzz's `compile` runs and what check_build.sh runs before asserting,
+# so the two cannot disagree about what building this project means. $SCRIPT_DIR rather than
+# $SRC: they are the same path in the container, and $SRC does not exist on the host.
+_BUILD_SH = (
+    "#!/bin/bash\n"
+    "set -euo pipefail\n"
+    "\n"
+    'SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"\n'
+    "\n"
+    'echo "=== build_library.sh ==="\n'
+    '"$SCRIPT_DIR/build_library.sh"\n'
+    'echo "=== compile_harnesses.sh ==="\n'
+    '"$SCRIPT_DIR/compile_harnesses.sh"\n'
+)
+
+
+def materialize(
+    workdir: Path,
+    analysis: AnalysisResult,
+    *,
+    parameters: BuildParameters,
+    base_image: str | None = None,
+) -> None:
+    """Write the full project layout into workdir, except build_library.sh.
+
+    Every file here is fixed or derives only from static analysis, so this runs before any
+    build attempt. That is what leaves a repair agent something runnable even when no build
+    system was identified: the gate it is told to run needs compile_harnesses.sh and a harness
+    source to exist regardless.
+
+    build_library.sh is written by exploration.write_build_library_script, which owns the
+    source-layout decision and rewrites it on each attempt.
+    """
+    workdir.mkdir(parents=True, exist_ok=True)
+    write_project_yaml(workdir, analysis)
+    write_dockerfile(workdir, analysis, include_bear=True, base_image=base_image)
+    write_build_sh(workdir)
+    write_harness_scripts(workdir, analysis.language, parameters=parameters)
+
+
+def write_harness_scripts(
+    workdir: Path, language: Language, *, parameters: BuildParameters
+) -> Path:
+    """Write compile_harness.sh, compile_harnesses.sh, and a default harness source.
+
+    The stub gives the gate's non-empty-$OUT assertion something to find before harness-link
+    discovery has run. Discovery later rewrites compile_harness.sh with each flag it resolves.
+    """
+    harness_source_dir = workdir / HARNESS_SOURCE_DIR
+    harness_source_dir.mkdir(parents=True, exist_ok=True)
+    write_default_fuzzer(harness_source_dir, language)
+    write_executable(
+        workdir / "compile_harness.sh",
+        build_harness_script(
+            LinkConfiguration(),
+            harness_cflags=parameters.harness_cflags,
+            harness_cxxflags=parameters.harness_cxxflags,
+        ),
+    )
+    return write_executable(workdir / "compile_harnesses.sh", build_harnesses_script())
+
+
+def write_project_yaml(output_path: Path, analysis: AnalysisResult) -> Path:
+    """Write project.yaml — depends only on analysis, so it never needs rewriting."""
+    path = output_path / "project.yaml"
+    path.write_text(
+        f"homepage: {analysis.clone_url}\n"
+        f"language: {analysis.language.value}\n"
+        "sanitizers:\n"
+        "  - address\n"
+        "  - undefined\n"
+        f"main_repo: {analysis.clone_url}\n"
+    )
+    return path
+
+
+def write_dockerfile(
+    output_path: Path,
+    analysis: AnalysisResult,
+    *,
+    include_bear: bool,
+    base_image: str | None = None,
+    system_packages: list[str] | None = None,
+) -> Path:
+    """Write the OSS-Fuzz project Dockerfile.
+
+    include_bear=True produces the workspace's live copy, so the image the exploration probe
+    runs in always has bear for Make/Autotools compile_commands.json capture.
+    include_bear=False produces the shipped copy, which must not need a FuzzPrep-only tool.
+    """
+    path = output_path / "Dockerfile"
+    lines = [
+        f"FROM {base_image or DEFAULT_BASE_IMAGE}\n",
+        f"ENV FUZZING_LANGUAGE={analysis.language.value}\n",
+    ]
+
+    apt_packages: list[str] = []
+    if include_bear:
+        apt_packages.append("bear")
+    if analysis.autotools_setup in {
+        AutotoolsSetup.AUTOGEN,
+        AutotoolsSetup.BOOTSTRAP,
+        AutotoolsSetup.AUTORECONF,
+    }:
+        apt_packages.extend(_AUTOTOOLS_PACKAGES)
+    apt_packages.extend(system_packages or [])
+    if apt_packages:
+        lines.append(f"{APT_INSTALL_PREFIX} {' '.join(dict.fromkeys(apt_packages))}\n")
+
+    lines.append(f"RUN git clone --recursive {analysis.clone_url} $SRC/src\n")
+    if analysis.repo_ref is not None:
+        lines.append(f"RUN git -C $SRC/src checkout {analysis.repo_ref}\n")
+    lines += [
+        f"COPY {HARNESS_SOURCE_DIR} $SRC/{HARNESS_SOURCE_DIR}\n",
+        "COPY build.sh build_library.sh compile_harness.sh compile_harnesses.sh $SRC/\n",
+        "WORKDIR $SRC/src\n",
+    ]
+    path.write_text("".join(lines))
+    return path
+
+
+def inject_apt_packages(output_path: Path, packages: list[str]) -> Path:
+    """Merge newly-discovered apt packages into an existing Dockerfile, in place.
+
+    Merges rather than re-renders, so agent edits survive: this file is written before the
+    harness phase can know what else is needed, and generation only ever copies it.
+    """
+    path = output_path / "Dockerfile"
+    if not packages:
+        return path
+    lines = path.read_text().splitlines(keepends=True)
+    for i, line in enumerate(lines):
+        if line.startswith(APT_INSTALL_PREFIX):
+            existing = line[len(APT_INSTALL_PREFIX) :].split()
+            merged = list(dict.fromkeys(existing + packages))
+            lines[i] = f"{APT_INSTALL_PREFIX} {' '.join(merged)}\n"
+            break
+    else:
+        insert_at = next(
+            (i + 1 for i, line in enumerate(lines) if line.startswith("ENV FUZZING_LANGUAGE=")),
+            len(lines),
+        )
+        lines.insert(insert_at, f"{APT_INSTALL_PREFIX} {' '.join(dict.fromkeys(packages))}\n")
+    path.write_text("".join(lines))
+    return path
+
+
+def write_build_sh(output_path: Path) -> Path:
+    """Write build.sh — the library build then harness compilation, with a marker per stage.
+
+    OSS-Fuzz's `compile` runs it, check_build.sh runs it and then asserts, and a host user can
+    run it directly.
+    """
+    return write_executable(output_path / "build.sh", _BUILD_SH)
+
+
+def strip_bear_dependency(dockerfile_content: str) -> str:
+    """Drop the "bear" apt package, which only the workspace image needs.
+
+    Splits the package list into tokens rather than replacing a fixed string, since "bear" is
+    not always followed by a space — it may be last in the list.
+    """
+    lines = []
+    for line in dockerfile_content.splitlines(keepends=True):
+        if not line.startswith(APT_INSTALL_PREFIX):
+            lines.append(line)
+            continue
+        packages = [pkg for pkg in line[len(APT_INSTALL_PREFIX) :].split() if pkg != "bear"]
+        if packages:
+            lines.append(f"{APT_INSTALL_PREFIX} {' '.join(packages)}\n")
+        # else: bear was the only package — drop the now-empty install line entirely.
+    return "".join(lines)
+
+
+def find_compile_commands(workdir: Path) -> Path | None:
+    """The compile_commands.json the gate's build left in workdir, or None if it left none.
+
+    Read from the layout rather than threaded through a result object, because threading it is
+    what lost it: the repair agents return a fresh result and had no field for it, so an
+    agent-fixed build published none even though the gate had just written one.
+
+    Whichever of these exists describes the build that actually passed. On the agent lane the
+    gate wipes `install` and `build` and rebuilds from nothing, so the capture is the gate's;
+    on the deterministic lane the gate skips the library build and the capture is the cold
+    build explore() ran, which is the same build the gate then accepted. `build/` comes first:
+    when `bear` is installed both exist for a CMake project, and CMake's own export does not
+    carry the compiler-probe entries (`CompilerIdC`, `TryCompile`) that bear observes.
+    """
+    for candidate in (
+        workdir / "build" / "compile_commands.json",
+        workdir / "compile_commands.json",
+    ):
+        if candidate.is_file():
+            return candidate
+    return None
+
+
+__all__ = [
+    "APT_INSTALL_PREFIX",
+    "DEFAULT_BASE_IMAGE",
+    "find_compile_commands",
+    "inject_apt_packages",
+    "materialize",
+    "strip_bear_dependency",
+    "write_build_sh",
+    "write_dockerfile",
+    "write_harness_scripts",
+    "write_project_yaml",
+]

fuzzprep-0.1.0.dist-info/METADATA

@@ -0,0 +1,255 @@
+Metadata-Version: 2.4
+Name: fuzzprep
+Version: 0.1.0
+Summary: Prepare software libraries for reproducible OSS-Fuzz project generation.
+Author: Trail of Bits
+Author-email: Trail of Bits <opensource@trailofbits.com>
+License-Expression: Apache-2.0
+License-File: LICENSE
+License-File: THIRD_PARTY_NOTICES.md
+Requires-Dist: pyyaml>=6.0
+Requires-Python: >=3.13
+Project-URL: Homepage, https://pypi.org/project/fuzzprep/
+Project-URL: Source, https://github.com/trailofbits/fuzzprep
+Project-URL: Issues, https://github.com/trailofbits/fuzzprep/issues
+Description-Content-Type: text/markdown
+
+# FuzzPrep
+
+FuzzPrep is a CLI that takes the manual effort out of building C/C++ libraries for fuzzing
+while aiming to minimize LLM token cost. It detects the build system, builds the library,
+probes harness compilation to find linker dependencies, and writes artifacts that build and
+link the library against a harness.
+
+## Prerequisites
+
+### What FuzzPrep needs
+
+- Python 3.13 and [`uv`](https://docs.astral.sh/uv/).
+- `git`, to clone the target repository.
+- `clang` and `clang++`, the default compilers. `--cc` and `--cxx` select others.
+- libFuzzer's runtime, which `clang` links for the default `-fsanitize=fuzzer` harness flags.
+  It is a separate package: `libclang-rt-dev` on Debian and Ubuntu, `compiler-rt` elsewhere.
+  A plain `apt install clang` pulls it in as a recommended package, but an install that uses
+  `--no-install-recommends` does not, so name it.
+
+```bash
+sudo apt update
+sudo apt install -y git clang libclang-rt-dev
+```
+
+### Common library build dependencies
+
+A target brings its own build dependencies: the build system it uses, and the `-dev` packages
+it links against. FuzzPrep reports the packages a failed run is missing. The below script also installs a set that covers many targets — the four supported build systems, the usual codegen and
+archive utilities, and the libraries FuzzPrep knows how to identify from error traces:
+
+```bash
+./scripts/install_common_deps.sh
+```
+
+The list is not exhaustive. When a build fails on a dependency the script does not cover,
+install that dependency and run again.
+
+### Optional
+
+- Docker, for `--environment oss-fuzz`.
+- The `claude` or `codex` CLI, for agent repair. It is on by default; `--no-agents` turns it
+  off and no CLI is then needed.
+- [`bear`](https://github.com/rizsotto/Bear), for Make and Autotools targets built with
+  `--environment local`. It captures `compile_commands.json`, which `extract-features` and
+  `generate-yaml` read.
+- `cmake`, `llvm-dev`, `libclang-20`, and `libclang-dev`, which `extract-features` builds its Clang
+  LibTooling parser against. With more than one LLVM installed, point `CMAKE_PREFIX_PATH` at
+  the tree the `clang` on `PATH` belongs to.
+
+The apt packages among these:
+
+```bash
+sudo apt install -y bear cmake llvm-dev libclang-dev libclang-20
+```
+
+## Install
+
+```bash
+uv sync
+```
+
+## Quickstart
+
+>**Best practice:** Run FuzzPrep in a container or disposable VM. FuzzPrep compiles and executes
+> arbitrary build-system logic from the target library. Its agentic workflow may also write and
+> execute build scripts, so it should be run in an isolated environment.
+
+From a local checkout after `uv sync`:
+
+```bash
+# Clones the repository, builds it, verifies it, and writes `output/zlib/`.
+uv run fuzzprep generate https://github.com/madler/zlib.git
+```
+
+To run FuzzPrep without cloning this repository:
+
+```bash
+uvx fuzzprep generate https://github.com/madler/zlib.git
+```
+
+Other useful flags include:
+
+```bash
+# Verify in the OSS-Fuzz Docker environment instead of on the host
+uv run fuzzprep generate <REPO_URL> --environment oss-fuzz
+
+# Turn off agent repair: a failed build then simply fails the run
+uv run fuzzprep generate <REPO_URL> --no-agents
+
+# Pass build-system configure options (repeat for more than one)
+uv run fuzzprep generate <REPO_URL> --library-configure-arg=-DCARES_STATIC=ON
+
+# Skip the from-scratch rebuild that validates an agent's repair, for a faster run
+uv run fuzzprep generate <REPO_URL> --bypass-scratch-validation
+
+# Use distinct library and final-harness instrumentation defaults
+uv run fuzzprep generate <REPO_URL> --environment local \
+  --cc clang --cxx clang++ \
+  --library-cflags='-fsanitize=fuzzer-no-link,address' \
+  --library-cxxflags='-fsanitize=fuzzer-no-link,address' \
+  --harness-cflags='-fsanitize=fuzzer,address' \
+  --harness-cxxflags='-fsanitize=fuzzer,address'
+```
+
+Agent repair is on by default and calls a paid network service. `--agent claude` (the
+default) or `--agent codex` selects the backend; `--no-agents` turns it off.
+
+See `uv run fuzzprep generate --help` for the full set of options (custom output
+location, pinning a branch/tag/commit, a different base image, etc).
+
+### Adaptable builds
+
+The generated build scripts let you supply your own toolchain and flags:
+
+```bash
+CC=afl-clang-fast CXX=afl-clang-fast++ \
+CFLAGS=-fsanitize=address CXXFLAGS=-fsanitize=address \
+  ./build_library.sh
+```
+
+### When a run fails
+
+FuzzPrep keeps its working state in `.fuzzprep/<project>/`: the workspace it built in,
+`logs/` with the raw output of each phase, and `stats.json`. A failed run writes no output
+directory, but the library build artifacts stay in `.fuzzprep/<project>/install/` if you want
+to debug the link line there. Add `--log-level debug` for more detail, or `--quiet` to hide
+the raw subprocess output while a phase runs.
+
+## What it does
+
+1. Detects the build system: CMake, Meson, Autotools, or Makefile.
+2. Builds the library with a deterministic script. If that build fails, an agent repairs it.
+3. Probes harness compilation to find transitive linker dependencies. If the probe fails,
+   an agent repairs it.
+4. Writes the output directory `<output>/<project>/`.
+
+## Output
+
+The output directory provides a reproducible OSS-Fuzz project and a standalone host build
+tree. `docker build .` works, and so does `./setup.sh && ./build_library.sh`.
+
+```
+output/<project>/
+├── Dockerfile             # OSS-Fuzz project files
+├── project.yaml           # OSS-Fuzz project metadata
+├── .dockerignore
+├── setup.sh               # Script for repo clone + apt dependencies
+├── build.sh               # Builds the library and compiles the provided harness
+├── build_library.sh       # build and install the library into install/
+├── compile_harness.sh     # compile and link one harness source
+├── compile_harnesses.sh   # compile every source in harness_source/ into out/
+├── harness_source/        # source code of all harnesses
+├── install/               # the library this run built
+├── compile_commands.json  # captured compile commands
+├── stats.json             # what this run did: durations, agent use, status
+└── README.md              # what this run verified, and how to run it
+```
+
+`harness_source/` starts with a stub — an `LLVMFuzzerTestOneInput` with a
+`// TODO: Add fuzzing logic` body. FuzzPrep proves the harness *compiles and links* against
+the library; writing the fuzzing logic is yours.
+
+## Environments
+
+`--environment` selects where this run builds and verifies. It does not change what is
+generated: the output directory always holds both setups. The generated `README.md` records
+which of the two this run exercised.
+
+- `local` — build and verify on the host.
+- `oss-fuzz` — build and verify in an OSS-Fuzz compatible Docker container, then prove the
+  generated Dockerfile builds from scratch.
+
+Neither environment isolates the target's build from your machine well enough to trust it.
+Run both inside a VM or an isolated machine.
+
+## Other commands
+
+`generate` produces a `compile_commands.json` file that two follow-on commands consume, to
+extract the library's API surface (`extract-features`) and to produce an OSS-Fuzz-Gen
+compatible YAML input (`generate-yaml`).
+
+```bash
+uv run fuzzprep extract-features <BUILD_PATH>   # -> features.json (run this first)
+uv run fuzzprep generate-yaml <BUILD_PATH>      # -> <project>.yaml
+```
+
+`extract-features` runs a Clang LibTooling-based parser over every header and source file in
+`compile_commands.json`. It writes `<BUILD_PATH>/features.json`, a structured inventory of
+the library's C/C++ declarations:
+
+- `functions` — name, return type, parameters, full signature, declaring header, and
+  whether it is public API (declared in a header, not `static`)
+- `typedefs` — name, underlying type, declaring header
+- `macros` — name, object- or function-like, parameters (if function-like), value,
+  declaring header
+- `enums` — name (if any), enumerators with their values, declaring header
+- `records` — structs and unions: name (if any), `kind`, fields, declaring header
+- `warnings` — non-fatal problems found during the parse
+
+`generate-yaml` reads `features.json` and keeps only the public functions. To get
+finer-grained output, name one or more headers and it keeps only the functions those headers
+declare:
+
+```bash
+uv run fuzzprep generate-yaml <BUILD_PATH> zlib.h zconf.h
+```
+
+Run `uv run fuzzprep --help` for details.
+
+## Security
+
+FuzzPrep clones and builds arbitrary third-party repositories, which runs their build systems
+on your machine, and it hands a repair agent write access to the run's workspace.
+
+Run it in a VM or on a dedicated machine you can wipe, whatever `--environment` you pick. A
+container shares the host kernel and is not a boundary that holds against code written to
+break out of one, so `--environment oss-fuzz` reduces the blast radius of an ordinary build
+but does not contain a hostile one. `--no-agents` turns agent repair off.
+
+[SECURITY.md](SECURITY.md) has the full threat model and tells you how to report a
+vulnerability.
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for the local setup, the checks a pull request must
+pass, and what each pytest marker needs. Participation is governed by the
+[Code of Conduct](CODE_OF_CONDUCT.md).
+
+## License
+
+FuzzPrep is licensed under [Apache-2.0](LICENSE).
+
+The `feature_extractor` tool that `extract-features` builds links cJSON and the LLVM/Clang
+libraries. [THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md) records their licenses and the
+notices that apply if you redistribute that binary.
+
+Some files under `tests/real_harnesses/` come from upstream projects and keep their own
+licenses; [that directory's README](tests/real_harnesses/README.md) records the provenance of
+each one.

fuzzprep-0.1.0.dist-info/RECORD

@@ -0,0 +1,56 @@
+fuzzprep/__init__.py,sha256=tr2-zP7nAwYvPIwHWMSf1BmGnXbB-5N7mN_ONxhPZAw,49
+fuzzprep/__main__.py,sha256=Vli4O9JijdrIzCVsmyfYeanw_oWjJ62kVkA5Q4UV0Gc,87
+fuzzprep/agents/harness_builder/SKILL.md,sha256=04sHLIhZ93zClkHSntUFhc74tLMAPlKLCNnvDyVGfrg,9090
+fuzzprep/agents/library_builder/SKILL.md,sha256=HncRQbGd0fKbbDrUwMsC46-oX0EHBxBddHHjx2KXqlc,8423
+fuzzprep/agents/scripts/check_build.sh,sha256=zHu8EkuHVPSG8RR6eH9lVghXGuKWHmigX_rzE_H3rMg,3463
+fuzzprep/agents/scripts/check_build_in_container.sh,sha256=PxX-eb1OIdJIK_lz8BEt3bDxCwN04ByBG-rtbvQNn1A,2972
+fuzzprep/agents/scripts/check_dockerfile_from_scratch.sh,sha256=O-qQWAxYXRr-_JxM-WGNpq604TSgWKBBLYtmDEVA4NE,1109
+fuzzprep/cli.py,sha256=EfA7m0LRI_aeayqLFOP4OZ3EPKcRzDNDEUw7F6ucwEo,41069
+fuzzprep/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fuzzprep/core/agent_stream.py,sha256=0rdKNFBUN-3I7cDs_ZR3ltrghnX9_X23mG-bID8yuts,10849
+fuzzprep/core/files.py,sha256=VjcTp-AIteIH4Cl5j_E4KA3qF4fGa29y66zT2Ft0k_A,1124
+fuzzprep/core/paths.py,sha256=Y6ilp0uQtBwIXNrAvODrzZo9gcEcu_GUvnC3Nam6N-E,792
+fuzzprep/core/reporting.py,sha256=YHeN8qINnsCaQvcCY1f462NH6QLiE2fMUGyLk3CDC44,7260
+fuzzprep/core/repos.py,sha256=lNUMKTT0OIstDMYCbHu9Am2rrTM0CcNURRkUHGFLZqE,8950
+fuzzprep/core/resources.py,sha256=Io3tqGZVlf2bAQ5cVY2dK4oY5KhFBRqOKIMrooE58lo,1643
+fuzzprep/core/subprocesses.py,sha256=1MankZ_OZy4ddYlN_SS5m2Xd7n8bLP2D0ytxzEqtxLU,6536
+fuzzprep/feature_extractor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fuzzprep/feature_extractor/benchmark_yaml.py,sha256=qCQbVEUBWtlXUVZ_4feWkZlj3KHZoTi-sTF-6KNSEEU,2906
+fuzzprep/feature_extractor/extraction.py,sha256=tQYNCUxfnLVOwEmb6xR3YhQwsSOw_0rKAf4hTiZ07ps,6317
+fuzzprep/feature_extractor/models.py,sha256=NtxeAICy_c58myoA2mWeXcIygbX_t8sOSAtqj3uQ9fc,1740
+fuzzprep/feature_extractor/native/.clang-format,sha256=Gy1Z5l97bDY7urRaehBX0PShvjrbMHuDIMCVGsVyEGk,19
+fuzzprep/feature_extractor/native/CMakeLists.txt,sha256=m_0a0a_VRxx6uhaTmRAaPscVYQfTm7owZIgwdUp1TMg,2798
+fuzzprep/feature_extractor/native/include/feature_extractor.hpp,sha256=pKTsFLdYnUl95iKD7daijOWD0RIBkF7YGmZnNB4QM00,4062
+fuzzprep/feature_extractor/native/src/extraction_action.cpp,sha256=ULcF_50PAZo6c0xP7qwuK21RyFf1V2PRAsYNjFX0fYY,9293
+fuzzprep/feature_extractor/native/src/json_writer.cpp,sha256=zU9Lv7982AMkiRUXms0F0s6-BrtbQnM3GYPC16yl9iI,5391
+fuzzprep/feature_extractor/native/src/macro_callbacks.cpp,sha256=qjhx4Bnuei357FzRvECo8RgZARL86lomkbQgbAl1Qpc,2384
+fuzzprep/feature_extractor/native/src/main.cpp,sha256=Doflnc45NtB8qjp4vRBx_b3wHU2aP4Z3m4inguemizs,4680
+fuzzprep/feature_extractor/native_build.py,sha256=R20UPQJ_eyZ3su5k51RAaotGa9DrqlZlkuds8I5z03g,4077
+fuzzprep/library_builder/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fuzzprep/library_builder/agents.py,sha256=2Ap_8076q9QkzgFSW7Fs0tkr0opErNXc9ZJcsvcuDrg,20009
+fuzzprep/library_builder/analysis.py,sha256=4D7pavJbSdb7BZb9DZnHJAk_kFM47ymce5IJuvSq9sE,5464
+fuzzprep/library_builder/build_parameters.py,sha256=TWeo1GQGbPTiLzI5djAAFR9ONjNkUuxXbkSd3bS64X8,6116
+fuzzprep/library_builder/dependency_resolution.py,sha256=7aQh7ntDCB2NcHf7P18K5zfBPYUxOeGPYSOIzvOyC70,4988
+fuzzprep/library_builder/environments/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fuzzprep/library_builder/environments/base.py,sha256=RrK7bJ8dOF5zIZiFE50qewJXTyMlg4Hq635pTCAfkXU,3409
+fuzzprep/library_builder/environments/gate.py,sha256=h5TU2piV5fUtRyMTy2t6g2q1zBMFgpDe6Qyi3NDnJz0,4194
+fuzzprep/library_builder/environments/local.py,sha256=LOLQwIsR827OK_hpYY-ogBrhYpS7TwtvX_f0vYioW70,9073
+fuzzprep/library_builder/environments/oss_fuzz.py,sha256=35H9I-lIAMzPrgVp7rHOfrcvUQK2aSjTFE7inD44QXI,20410
+fuzzprep/library_builder/environments/verification.py,sha256=obRXSMvM_3QcOomTh6LrAcn0MrwMJvn3YROzsEwHvy8,4858
+fuzzprep/library_builder/exploration.py,sha256=vLQa3aTfko9WaC1tHwA6gQlW0Pz7qh3VT82qHw1UlzQ,8195
+fuzzprep/library_builder/generation.py,sha256=VwL6sVRKPT95Ocp6NObgicvvjohT8XW8kTDVaOVpEWw,13537
+fuzzprep/library_builder/harness_explorer.py,sha256=c24Ly5Ugnb3KVDBPJYdYQnknuZdw9YK1h5du0qIPa6M,9851
+fuzzprep/library_builder/models.py,sha256=SYWHsnVykYZwN0X7mfiHqG3bxUO2YCEeqsKzy1c3AZ4,5745
+fuzzprep/library_builder/package_names.json,sha256=TBKO6NNLY5g5puB-7VIuM0yd2Dhu3OV9Sla5Nfvvg78,984
+fuzzprep/library_builder/package_names.py,sha256=BbOgBof8vgoXOgeUg5Re5K8j8S_E3t3XHZgQmmUcYIU,1153
+fuzzprep/library_builder/scripts.py,sha256=YtJ7tuXU5-gxoHx72xfi4k4I-iPdCoAtHPg6HisiFqc,15264
+fuzzprep/library_builder/stats.py,sha256=nOtpo7bVycr_8PMYD6-ko9cdBtsXsy1k9mWXAoKZ0F8,3817
+fuzzprep/library_builder/symbol_patterns.json,sha256=QE9GVcTmCzl16vm0f8pB8QggEywwFhxqVKLPx5zo6o4,2011
+fuzzprep/library_builder/timeouts.py,sha256=8DlI6TJyPFiRKiFWUinxIK_H4DV0JBqERgz373FFids,566
+fuzzprep/library_builder/workspace.py,sha256=sIUi4_sz9w_sMOk1IN8Z1L6Vj9Dltll7z-l8PbuA4CE,9758
+fuzzprep-0.1.0.dist-info/licenses/LICENSE,sha256=TXPiF794qJbbb6wtrr2WqSpDFm3rAvHqkqBIhmMYADE,11377
+fuzzprep-0.1.0.dist-info/licenses/THIRD_PARTY_NOTICES.md,sha256=HrCPPPGcVFjX7l69JZEH34oAqqyal8lb4pNpkbXbTks,2515
+fuzzprep-0.1.0.dist-info/WHEEL,sha256=nQ0eT7mepDP-DkLACRDiCUi7cAIJyLg4OevuC4KpLLY,80
+fuzzprep-0.1.0.dist-info/entry_points.txt,sha256=ujRytgUod2sT08KmZe3BIGBxfeRouaq5NKHWYmP82A0,53
+fuzzprep-0.1.0.dist-info/METADATA,sha256=jctV5zz-4LjrFUN2paL47wI3QDEnnWW-R4VZOhheon0,10412
+fuzzprep-0.1.0.dist-info/RECORD,,

fuzzprep-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.12.4
+Root-Is-Purelib: true
+Tag: py3-none-any

fuzzprep-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+fuzzprep = fuzzprep.__main__:main
+