Add Phoenix-bench code and evaluation artifacts

.gitattributes

@@ -796,3 +796,12 @@ snapshots/FPGA-MAFIA_fpga_mafia_pr479/FPGA/SDRAM_RTL_Test/DE10_LITE_SDRAM_RTL_Te
 snapshots/FPGA-MAFIA_fpga_mafia_pr479/FPGA/SDRAM_RTL_Test/DE10_LITE_SDRAM_RTL_Test.pof filter=lfs diff=lfs merge=lfs -text
 snapshots/FPGA-MAFIA_fpga_mafia_pr479/FPGA/SDRAM_RTL_Test/demo_batch/DE10_LITE_SDRAM_RTL_Test.sof filter=lfs diff=lfs merge=lfs -text
 snapshots/jotego_jtcores_pr960/cores/s16b/doc/315-5195_schematics.pdf filter=lfs diff=lfs merge=lfs -text
+Repos/HWE/agents/Agentless/test_agentless/apfaudio_eurorack-pmod_pr36/hardware/datasheets/XZMDKVG55W-4.pdf filter=lfs diff=lfs merge=lfs -text
+Repos/HWE/agents/Agentless/test_agentless/apfaudio_eurorack-pmod_pr36/hardware/datasheets/ak4619vn-en-datasheet.pdf filter=lfs diff=lfs merge=lfs -text
+Repos/HWE/agents/Agentless/test_agentless/apfaudio_eurorack-pmod_pr36/hardware/datasheets/pj-301b.pdf filter=lfs diff=lfs merge=lfs -text
+Repos/HWE/agents/Agentless/test_agentless/apfaudio_eurorack-pmod_pr36/hardware/datasheets/pj-324m0.pdf filter=lfs diff=lfs merge=lfs -text
+Repos/HWE/agents/Agentless/test_agentless/apfaudio_eurorack-pmod_pr36/hardware/datasheets/pmod-interface-specification-1_2_0.pdf filter=lfs diff=lfs merge=lfs -text
+Repos/HWE/agents/Lingxi/docs/Lingxi[[:space:]]Technical[[:space:]]Report[[:space:]]2505.pdf filter=lfs diff=lfs merge=lfs -text
+Repos/HWE/agents/Lingxi/docs/Lingxi[[:space:]]v1.5[[:space:]]Technical[[:space:]]Report[[:space:]]200725.pdf filter=lfs diff=lfs merge=lfs -text
+Repos/HWE/agents/Lingxi/docs/Lingxi[[:space:]]v2.0[[:space:]]Technical[[:space:]]Report[[:space:]]2026.pdf filter=lfs diff=lfs merge=lfs -text
+Repos/HWE/agents/Lingxi/imgs/overview_fig.pdf filter=lfs diff=lfs merge=lfs -text

Repos/HWE/README.md

@@ -0,0 +1,63 @@
+# HWE — Phoenix-bench Code Release
+
+Code that backs the paper *Phoenix-bench: A Hardware Engineering Benchmark for Agentic AI* (NeurIPS 2026). The companion data (per-instance snapshots, full Verilator testbenches, Docker images) lives at the project page; this tree holds source code, scripts, agent run artifacts, and lightweight metadata (~2.2 GB).
+
+All paths and identifiers in this release have been anonymized; absolute paths in scripts and logs point at `/workspace/phoenix-bench/`, which the verifier maps to the snapshot/testbench layout described under "Data NOT included" below.
+
+## Layout
+
+```
+HWE/
+├── agents/             # the 8 agentic frameworks evaluated in §4.2
+│   ├── Agentless/      # workflow-based  (Xia et al. 2024)
+│   ├── Aider/          # interactive     (paul-gauthier 2024)
+│   ├── ExpeRepair/     # retrieval-aug.  (Mu et al. 2025)
+│   ├── KGCompass/      # knowledge-graph (2025)
+│   ├── Lingxi/         # multi-agent     (2025)
+│   ├── mini-swe-agent/ # minimal SWE-agent variant (2025)
+│   ├── OpenHands/      # interactive     (Wang et al. 2024)
+│   └── SWE-agent/      # interactive     (Yang et al. 2024)
+└── benchmark/
+    ├── construction/   # §3.1 funnel: GitHub crawl → issue/PR filtering
+    ├── verifier/       # §3 Phoenix-Ref harness + gold patches
+    └── eval_harness/   # §4 product+open-source agent evaluation scaffolds
+```
+
+## Mapping to the paper
+
+| Paper element | Code path |
+|---|---|
+| §3.1 Data collection / 4-stage funnel | `benchmark/construction/` |
+| §3 Phoenix-Ref harness (511 instances) | `benchmark/verifier/` |
+| §3 Patch complexity / difficulty tiers (Tab 2, App C) | `benchmark/verifier/classify_patch_complexity.py`, `patch_complexity*` |
+| §3 F2P / P2P verification | `benchmark/verifier/count_fail_to_pass.{py,sh}`, `f2p_sweep_one.sh` |
+| §3 Coverage statistics (Tab 2) | `benchmark/verifier/collect_*coverage*.py` |
+| §3 Issue classification (Fig 3) | `benchmark/verifier/classified_issues_full.json`, `classify_missing_issues.py` |
+| §4.1 Four product agents | `benchmark/eval_harness/benchmark_{claude,codex,codex_new,copilot,gemini}/` |
+| §4.2 Eight open-source agents | `agents/` |
+| §4.2 mini-SWE-agent runs | `benchmark/eval_harness/benchmark_mini_agent/` |
+| §4.3 File-level oracle localization | `benchmark/eval_harness/benchmark_localizations/` |
+| §4.3 Testbench-feedback diagnostic | `benchmark/eval_harness/benchmark_eda/` |
+
+## Data NOT included (download separately)
+
+These are required to actually re-run the benchmark; omitted here for size.
+
+| Artifact | Original location | Size |
+|---|---|---|
+| Per-instance snapshots (511 × repo HEAD) | `HDL_verified_new/snapshots/` | 21 GB |
+| Per-instance Verilator testbenches | `HDL_verified_new/testbench_verilator/` | 16 GB |
+| OpenHands eval outputs (per-instance logs) | `openhands_eval/benchmarks/eval_outputs/` | 9.5 GB |
+
+`benchmark/verifier/patches/` (122 MB, gold developer patches) IS included — needed for F2P verification once snapshots are restored.
+
+## Reproducing F2P verification
+
+```bash
+# After downloading snapshots/ and testbench_verilator/ into benchmark/verifier/
+cd benchmark/verifier
+ls testbench_verilator/ > /tmp/instances.txt
+SWEEP_CSV=/tmp/f2p.csv xargs -P 16 -I {} ./f2p_sweep_one.sh {} < /tmp/instances.txt
+```
+
+The included `f2p_full_sweep_2026-05-27.csv` is a snapshot of the 511-instance sweep run on 2026-05-27 (475 PASS / 32 FAIL / 3 ERROR / 1 misclassified).

Repos/HWE/agents/Agentless/.gitignore

@@ -0,0 +1,187 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#  nuclear option because steven uses PyCharm.
+.idea/
+
+# some project specific stuff
+
+/get_repo_structure/astropy
+/get_repo_structure/django
+/get_repo_structure/flask
+/get_repo_structure/pylint
+/get_repo_structure/pytest
+/get_repo_structure/requests
+/get_repo_structure/seaborn
+/get_repo_structure/scikit-learn
+/get_repo_structure/sphinx
+/get_repo_structure/matplotlib
+/get_repo_structure/sympy
+/get_repo_structure/xarray
+get_repo_structure/test_repo/
+results/
+logs/
+dev/
+
+# data files
+*.jsonl
+*.json
+
+# Jupyter Notebooks
+*.ipynb

Repos/HWE/agents/Agentless/.pre-commit-config.yaml

@@ -0,0 +1,21 @@
+repos:
+-   repo: https://github.com/pycqa/isort
+    rev: 5.12.0
+    hooks:
+    -   id: isort
+        name: isort (python)
+        args: ["--profile", "black"]
+-   repo: https://github.com/psf/black
+    rev: 22.6.0
+    hooks:
+    -   id: black
+-   repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.3.0
+    hooks:
+    -   id: check-yaml
+    -   id: end-of-file-fixer
+    -   id: trailing-whitespace
+exclude: |
+    (?x)^(
+        README.*
+    )$

Repos/HWE/agents/Agentless/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 OpenAutoCoder
+
+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.

Repos/HWE/agents/Agentless/README.md

@@ -0,0 +1,102 @@
+# 😺 Agentless
+
+<p align="center">
+    <a href="https://arxiv.org/abs/2407.01489"><img src="https://img.shields.io/badge/📃-Arxiv-b31b1b?style=for-the-badge"></a>
+    <a href="https://github.com/OpenAutoCoder/Agentless/blob/master/LICENSE"><img src="https://forthebadge.com/images/badges/license-mit.svg" style="height: 28px"></a>
+</p>
+
+<p align="center">
+    <big><a href="#-news">😽News</a></big> |
+    <big><a href="#-setup">🐈Setup</a></big> |
+    <big><a href="#-comparison">🧶Comparison</a></big> | 
+    <big><a href="#-artifacts">🐈‍⬛Artifacts</a></big> |
+    <big><a href="#-citation">📝Citation</a></big> |
+    <big><a href="#-acknowledgement">😻Acknowledgement</a></big>
+</p>
+
+## 😽 News 
+
+- *Dec 2nd, 2024*: We integrated Agentless with Claude 3.5 Sonnet to achieve 40.7% and 50.8% solve rate on SWE-bench lite and verified 
+- *Oct 28th, 2024*: We just released OpenAutoCoder-Agentless 1.5! 
+- *July 1st, 2024*: We just released OpenAutoCoder-Agentless 1.0! **Agentless** currently is the best open-source approach on SWE-bench lite with 82 fixes (27.3%) and costing on average $0.34 per issue.
+
+## 😺 About 
+
+**Agentless** is an *agentless* approach to automatically solve software development problems. To solve each issue, **Agentless** follows a simple three phase process: localization, repair, and patch validation.
+- 🙀 **Localization**: Agentless employs a hierarchical process to first localize the fault to specific files, then to relevant classes or functions, and finally to fine-grained edit locations
+- 😼 **Repair**: Agentless takes the edit locations and samples multiple candidate patches per bug in a simple diff format
+- 😸 **Patch Validation**: Agentless selects the regression tests to run and generates additional reproduction test to reproduce the original error. Using the test results, Agentless re-ranks all remaining patches to selects one to submit
+
+## 🐈 Setup
+
+First create the environment 
+
+```shell
+git clone https://github.com/OpenAutoCoder/Agentless.git
+cd Agentless
+
+conda create -n agentless python=3.11 
+conda activate agentless
+pip install -r requirements.txt
+export PYTHONPATH=$PYTHONPATH:$(pwd)
+```
+
+<details><summary>⏬ Developer Setup</summary>
+<div>
+
+```shell
+# for contribution, please install the pre-commit hook.
+pre-commit install  # this allows a more standardized code style
+```
+
+</div>
+</details>
+
+Then export your OpenAI API key 
+```shell
+export OPENAI_API_KEY={key_here}
+```
+
+Now you are ready to run **Agentless** on the problems in SWE-bench! 
+
+> [!NOTE]
+> 
+> To reproduce the full SWE-bench lite experiments and follow our exact setup as described in the paper. Please see this [README](https://github.com/OpenAutoCoder/Agentless/blob/main/README_swebench.md)
+
+## 🧶 Comparison
+
+Below shows the comparison graph between **Agentless** and the best open-source agent-based approaches on SWE-bench lite
+
+<p align="center">
+<img src="./resources/comparison_graph.png" style="width:75%; margin-left: auto; margin-right: auto;">
+</p>
+
+## 🐈‍⬛ Artifacts
+
+You can download the complete artifacts of **Agentless** in our [v1.5.0 release](https://github.com/OpenAutoCoder/Agentless/releases/tag/v1.5.0):
+- 🐈‍⬛ agentless_swebench_lite: complete Agentless run on SWE-bench Lite
+- 🐈‍⬛ agentless_swebench_verified: complete Agentless run on SWE-bench Verified
+- 🐈‍⬛ swebench_repo_structure: preprocessed structure information for each SWE-Bench problem
+
+You can also checkout `classification/` folder to obtain our manual classifications of SWE-bench-lite as well as our filtered SWE-bench-lite-*S* problems.
+
+## 📝 Citation
+
+```bibtex
+@article{agentless,
+  author    = {Xia, Chunqiu Steven and Deng, Yinlin and Dunn, Soren and Zhang, Lingming},
+  title     = {Agentless: Demystifying LLM-based Software Engineering Agents},
+  year      = {2024},
+  journal   = {arXiv preprint},
+}
+```
+
+> [!NOTE]
+> 
+> The first two authors contributed equally to this work, with author order determined via [*Nigiri*](https://senseis.xmp.net/?Nigiri)
+
+## 😻 Acknowledgement 
+
+* [SWE-bench](https://www.swebench.com/)
+* [Aider](https://github.com/paul-gauthier/aider)
+* [SWE-bench-docker](https://github.com/aorwall/SWE-bench-docker)

Repos/HWE/agents/Agentless/README_swebench.md

@@ -0,0 +1,374 @@
+# Agentless experiments on SWE-Bench
+
+<p align="center">
+    <big><a href="#-setup">🐈Setup</a></big> |
+    <big><a href="#-localization">🙀Localization</a></big> | 
+    <big><a href="#-repair">😼Repair</a></big> |
+    <big><a href="#-patch-validation-and-selection">😸Patch Validation and Selection</a></big> |
+    <big><a href="#-cost">💰Cost</a></big>
+</p>
+
+In this document, we will go through the steps to generate the patches on SWE-bench. 
+Currently, we support both [SWE-Bench Lite](https://huggingface.co/datasets/princeton-nlp/SWE-bench_Lite) and [SWE-Bench Verified](https://huggingface.co/datasets/princeton-nlp/SWE-bench_Verified)
+
+## 🐈 Setup
+
+First create the environment 
+
+```shell
+git clone https://github.com/OpenAutoCoder/Agentless.git
+cd Agentless
+
+conda create -n agentless python=3.11 
+conda activate agentless
+pip install -r requirements.txt
+export PYTHONPATH=$PYTHONPATH:$(pwd)
+```
+
+Then export your OpenAI API key 
+```shell
+export OPENAI_API_KEY={key_here}
+```
+
+Create the folder to save our results
+```shell
+mkdir results # where we will save our results
+```
+
+> [!TIP]
+> 
+> We currently support SWE-Bench Lite and SWE-Bench Verified benchmarks, you can use `--dataset` to select the benchmark (by default it will be SWE-Bench Lite)
+> 
+> For example `--dataset=princeton-nlp/SWE-bench_Verified`
+
+> [!TIP]
+> 
+> Since for each issue in the benchmark (both SWE-Bench Lite and SWE-Bench Verified) we need to checkout the repository and process the files, you might want to save some time by downloading the preprocessed data here: [swebench_lite_repo_structure.zip](https://github.com/OpenAutoCoder/Agentless/releases/tag/v1.5.0)
+>
+> After downloading, please unzip and export the location as such `export PROJECT_FILE_LOC={folder which you saved}`
+
+> [!TIP]
+> 
+> You can use `--target_id` to specific a particular bug you want to target. 
+> 
+> For example `--target_id=django__django-10914`
+
+> [!TIP]
+> 
+> We use multiple threads (controllable via `--num_threads`) to speed up the Agentless process 
+
+## 🙀 Localization 
+
+In localization, the goal is to find the locations in source code where we need to edit to fix the issues. 
+At a high-level, **Agentless** uses a 3-stage localization step to first localize to specific files, then to relevant code elements, and finally to fine-grained edit locations. 
+We will now take you through the step-by-step procedure of Agentless in each of the localization steps.
+
+#### 1. Localize to suspicious files
+
+First, we localize to suspicious files. This is done in a multi-step process where we combine both LLM localized files with retrieval files.
+
+Run the following command to generate the LLM-predicted suspicious files:
+
+```shell
+python agentless/fl/localize.py --file_level \
+                                --output_folder results/swe-bench-lite/file_level \
+                                --num_threads 10 \
+                                --skip_existing 
+```
+
+This will save all the LLM-predicted suspicious file locations in  `results/swe-bench-lite/file_level/loc_outputs.jsonl` with the logs saved in `results/swe-bench-lite/file_level/localization_logs`
+
+We then complement the previous suspicious files with a simple embedding-based retrieval method to identify additional suspicious files.
+
+This is done by first filtering out irrelevant folders by using LLM to produce a list of irrelevant folders that do not need to be retrieved from with the following command:
+
+```shell
+python agentless/fl/localize.py --file_level \
+                                --irrelevant \
+                                --output_folder results/swe-bench-lite/file_level_irrelevant \
+                                --num_threads 10 \
+                                --skip_existing 
+```
+
+This will save the identified irrelevant folders in `results/swe-bench-lite/file_level_irrelevant/loc_outputs.jsonl` with the logs saved in `results/swe-bench-lite/file_level_irrelevant/localization_logs`
+
+We then perform the retrieval (note the embedding is done with OpenAI `text-embedding-3-small` model) by passing in the irrelevant folders and running the following command: 
+
+```shell
+python agentless/fl/retrieve.py --index_type simple \
+                                --filter_type given_files \
+                                --filter_file results/swe-bench-lite/file_level_irrelevant/loc_outputs.jsonl \
+                                --output_folder results/swe-bench-lite/retrievel_embedding \
+                                --persist_dir embedding/swe-bench_simple \
+                                --num_threads 10 
+```
+
+This will save the retrieved files in `results/swe-bench-lite/retrievel_embedding/retrieve_locs.jsonl` with the logs saved in `results/swe-bench-lite/retrievel_embedding/retrieval_logs`
+
+Finally we merge the LLM-predicted suspicious file locations with the embedding-based retrieved files to obtain a final list of relevant files:
+
+```shell
+python agentless/fl/combine.py  --retrieval_loc_file results/swe-bench-lite/retrievel_embedding/retrieve_locs.jsonl \
+                                --model_loc_file results/swe-bench-lite/file_level/loc_outputs.jsonl \
+                                --top_n 3 \
+                                --output_folder results/swe-bench-lite/file_level_combined 
+```
+
+`results/swe-bench-lite/file_level_combined/combined_locs.jsonl` contains the final list of suspicious files identified by Agentless.
+
+#### 2. localize to related elements
+
+Next, we move on to localizing the related elements.
+
+Run the following command to provide the suspicious files from the first stage as input:
+
+```shell
+python agentless/fl/localize.py --related_level \
+                                --output_folder results/swe-bench-lite/related_elements \
+                                --top_n 3 \
+                                --compress_assign \
+                                --compress \
+                                --start_file results/swe-bench-lite/file_level_combined/combined_locs.jsonl \
+                                --num_threads 10 \
+                                --skip_existing 
+```
+
+This will save the related elements in `results/swe-bench-lite/related_elements/loc_outputs.jsonl` with the logs saved in `results/swe-bench-lite/related_elements/localization_logs`
+
+#### 3. localize to edit locations
+
+Finally, using the related elements, we then localize to the edit locations. This is done via sampling to obtain multiple different sets of edit locations:
+
+
+```shell
+python agentless/fl/localize.py --fine_grain_line_level \
+                                --output_folder results/swe-bench-lite/edit_location_samples \
+                                --top_n 3 \
+                                --compress \
+                                --temperature 0.8 \
+                                --num_samples 4 \
+                                --start_file results/swe-bench-lite/related_elements/loc_outputs.jsonl \
+                                --num_threads 10 \
+                                --skip_existing 
+```
+
+This will save the edit locations in `results/swe-bench-lite/edit_location_samples/loc_outputs.jsonl` with the logs saved in `results/swe-bench-lite/edit_location_samples/localization_logs`
+
+<details><summary>⏬ Structure of `loc_outputs.jsonl` <i>:: click to expand ::</i> </summary>
+<div>
+
+- `instance_id`: task ID of the issue
+- `found_files`: list of files localized by the model
+- `additional_artifact_loc_file`: raw output of the model during file-level localization
+- `file_traj`: trajectory of the model during file-level localization (e.g., \# of tokens)
+- `found_related_locs`: dict of relevant code elements localized by the model
+- `additional_artifact_loc_related`: raw output of the model during relevant-code-level localization 
+- `related_loc_traj`: trajectory of the model during relevant-code-level localization
+- `found_edit_locs`: dict of edit locations localized by the model
+- `additional_artifact_loc_edit_location`: raw output of the model during edit-location-level localization 
+- `edit_loc_traj`: trajectory of the model during edit-location-level localization
+
+</div>
+</details>
+
+Run the following command to separate the individual sets of edit locations:
+
+```shell
+python agentless/fl/localize.py --merge \
+                                --output_folder results/swe-bench-lite/edit_location_individual \
+                                --top_n 3 \
+                                --num_samples 4 \
+                                --start_file results/swe-bench-lite/edit_location_samples/loc_outputs.jsonl 
+```
+
+The separate sets of edit locations can be found in `results/swe-bench-lite/edit_location_individual`. The location files will be named `loc_merged_{x}-{x}_outputs.jsonl` where `x` indicates the individual samples. For our experiments on SWE-bench, we will use all 4 sets of edit locations and perform repairs on them individually to generate 4 different repair runs.
+
+## 😼 Repair
+
+Using the 4 sets of edit locations from before, we now perform repair. 
+
+**Agentless** generates multiple patches per issue (controllable via parameters) and then perform majority voting with patch validation to select the final patch for submission 
+
+Run the following command to generate the patches:
+
+```shell
+python agentless/repair/repair.py --loc_file results/swe-bench-lite/edit_location_individual/loc_merged_0-0_outputs.jsonl \
+                                  --output_folder results/swe-bench-lite/repair_sample_1 \
+                                  --loc_interval \
+                                  --top_n=3 \
+                                  --context_window=10 \
+                                  --max_samples 10  \
+                                  --cot \
+                                  --diff_format \
+                                  --gen_and_process \
+                                  --num_threads 2 
+```
+
+<details><summary>Additional Repair Commands</summary>
+<div>
+
+```shell
+for i in {1..3}; do
+    python agentless/repair/repair.py --loc_file results/swe-bench-lite/edit_location_individual/loc_merged_${i}-${i}_outputs.jsonl \
+                                    --output_folder results/swe-bench-lite/repair_sample_$((i+1)) \
+                                    --loc_interval \
+                                    --top_n=3 \
+                                    --context_window=10 \
+                                    --max_samples 10  \
+                                    --cot \
+                                    --diff_format \
+                                    --gen_and_process \
+                                    --num_threads 2 
+done
+
+```
+</div>
+</details>
+
+These commands generate 10 samples each (1 greedy and 9 via temperature sampling) as defined `--max_samples 10`. The `--context_window` indicates the amount of code lines before and after each localized edit location we provide to the model for repair. The patches are saved in `results/swe-bench-lite/repair_sample_{i}/output.jsonl`, which contains the raw output of each sample as well as any trajectory information (e.g., number of tokens). The complete logs are also saved in `results/swe-bench-lite/repair_sample_{i}/repair_logs/` 
+
+The above commands will combine to generate 40 samples in total for each bug. 
+
+## 😸 Patch Validation and Selection 
+
+Since Agentless generates multiple candidate patches per issue, we need a way to select a final patch for submission.
+
+To do this, Agentless leverages both regression tests that exist in the codebase as well as generating new reproduction tests that can verify if the patch can solve the original issue.
+
+#### Regression test selection
+
+We first select a set of regression tests (tests that already exist in the repository and pass on the original codebase) to run.
+
+Run the following command to get a list of passing tests in the original codebase:
+
+```shell
+python agentless/test/run_regression_tests.py --run_id generate_regression_tests \
+                                              --output_file results/swe-bench-lite/passing_tests.jsonl 
+```
+
+This will generate a list of passing tests at `results/swe-bench-lite/passing_tests.jsonl`
+
+> [!NOTE]
+> 
+> We do not use any of provided PASS_TO_PASS field in the SWE-bench benchmark
+> 
+> We select tests from the complete list of tests which can pass in the original repository
+
+Next, we ask the LLM to remove any tests which should not be ran with the following command:
+
+```shell
+python agentless/test/select_regression_tests.py --passing_tests results/swe-bench-lite/passing_tests.jsonl \
+                                                 --output_folder results/swe-bench-lite/select_regression 
+```
+
+This will produce a list of final regression tests in `results/swe-bench-lite/select_regression/output.jsonl` with the logs at `results/swe-bench-lite/select_regression/select_test_logs`
+
+We can run this on all the patches generate, repeated for each repair run (i.e., by changing `folder`):
+
+```shell
+folder=results/swe-bench-lite/repair_sample_1
+for num in {0..9..1}; do
+    run_id_prefix=$(basename $folder); 
+    python agentless/test/run_regression_tests.py --regression_tests results/swe-bench-lite/select_regression/output.jsonl \
+                                                  --predictions_path="${folder}/output_${num}_processed.jsonl" \
+                                                  --run_id="${run_id_prefix}_regression_${num}" --num_workers 10;
+done
+```
+
+This will output the regression test results in the same folder as the repair results. `results/swe-bench-lite/repair_sample_1/output_{i}_regression_test_results.jsonl` contains the regression test results for each patch number (`i`). 
+
+> [!NOTE]
+> 
+> We also perform post-processing to generate the complete git-diff patch for each repair sample.
+> 
+> You can find the individual patch in `results/repair/output_{i}_processed.jsonl` where `i` is the sample number. 
+
+#### Reproduction test generation
+
+In addition to the regression tests, Agentless also generates a reproduction test that attempt to check if the patch can solve the original issue.
+
+Similar to patch generation, Agentless also generates multiple samples of reproduction tests, and then perform selection:
+```shell
+python agentless/test/generate_reproduction_tests.py --max_samples 40 \
+                                                     --output_folder results/swe-bench-lite/reproduction_test_samples \
+                                                     --num_threads 10 
+```
+
+This will generate 40 samples (1 greedy + 39 temperature sampling) per issue. The generated reproduction tests can be found in `results/swe-bench-lite/reproduction_test_samples/output.jsonl`. The corresponding logs can be found in `results/swe-bench-lite/reproduction_test_samples/generating_test_logs/`.
+
+Now we will execute each of these generated tests on the original repository to see if they can reproduce the original issue.
+
+```shell
+for st in {0..36..4}; do   en=$((st + 3));   
+        echo "Processing ${st} to ${en}";   
+        for num in $(seq $st $en); do     
+            echo "Processing ${num}";     
+            python agentless/test/run_reproduction_tests.py --run_id="reproduction_test_generation_filter_sample_${num}" \
+                                                            --test_jsonl="results/swe-bench-lite/reproduction_test_samples/output_${num}_processed_reproduction_test.jsonl" \
+                                                            --num_workers 6 \
+                                                            --testing;
+done & done
+```
+
+> [!WARNING]
+> 
+> In the above command we execute multiple SWE-bench evaluations in parallel, please ensure that your machine is able to handle that
+>
+> If not, you may want to reduce the amount of parallelization 
+
+This produces verification results for each tests in the same folder: `results/swe-bench-lite/reproduction_test_samples/`
+
+We then perform majority voting to select one reproduction test per issue:
+
+```shell
+python agentless/test/generate_reproduction_tests.py --max_samples 40 \
+                                                     --output_folder results/swe-bench-lite/reproduction_test_samples \
+                                                     --output_file reproduction_tests.jsonl \
+                                                     --select
+```
+
+This will generate the reproduction test file at: `results/swe-bench-lite/reproduction_test_samples/reproduction_tests.jsonl`
+
+Finally, we evaluate the generated patches on the selected reproduction test. Similar to regression test execution, this is repeated for each repair run (i.e., by changing `folder`):
+
+```shell
+folder=results/swe-bench-lite/repair_sample_1
+for num in {0..9..1}; do
+    run_id_prefix=$(basename $folder); 
+    python agentless/test/run_reproduction_tests.py --test_jsonl results/swe-bench-lite/reproduction_test_samples/reproduction_tests.jsonl \
+                                                    --predictions_path="${folder}/output_${num}_processed.jsonl" \
+                                                    --run_id="${run_id_prefix}_reproduction_${num}" --num_workers 10;
+done
+```
+
+ This will output the reproduction test results in the same folder as the repair results. `results/swe-bench-lite/repair_sample_1/output_{i}_reproduction_test_results.jsonl` contains the reproduction test results for each patch number (`i`). 
+
+
+#### Reranking and patch selection 
+
+Finally, using the regression and reproduction test results, Agentless performs reranking to select the final patch for submission.
+
+Run the following command (`--regression` indicates we are using regression tests for selection `--reproduction` indicates we are using the reproduction tests for selection)
+
+```shell
+python agentless/repair/rerank.py --patch_folder results/swe-bench-lite/repair_sample_1/,results/swe-bench-lite/repair_sample_2/,results/swe-bench-lite/repair_sample_3/,results/swe-bench-lite/repair_sample_4/ \
+                                  --num_samples 40 \
+                                  --deduplicate \
+                                  --regression \
+                                  --reproduction
+```
+
+This command will produced the `all_preds.jsonl` that contains the final selected patch for each instance_id which you can then directly use your favorite way of testing SWE-bench for evaluation!
+
+
+## 💰 Cost 
+
+To measure the cost of running Agentless, we have provided helpful utilities. 
+
+For each of the `output.jsonl` files produced for each of the steps (including substeps), run the following command:
+
+```shell
+python dev/util/cost.py --output_file example_step/output.jsonl 
+```
+
+This will output the dollar cost as well as the number of tokens. `--embedding_cost` can be used to compute the cost of the embedding step. 

Repos/HWE/agents/Agentless/agentless/fl/FL.py

@@ -0,0 +1,775 @@
+from abc import ABC, abstractmethod
+
+from agentless.repair.repair import construct_topn_file_context
+from agentless.util.compress_file import get_skeleton
+from agentless.util.postprocess_data import extract_code_blocks, extract_locs_for_files
+from agentless.util.preprocess_data import (
+    correct_file_paths,
+    get_full_file_paths_and_classes_and_functions,
+    get_repo_files,
+    line_wrap_content,
+    show_project_structure,
+)
+
+MAX_CONTEXT_LENGTH = 128000
+
+
+class FL(ABC):
+    def __init__(self, instance_id, structure, problem_statement, **kwargs):
+        self.structure = structure
+        self.instance_id = instance_id
+        self.problem_statement = problem_statement
+
+    @abstractmethod
+    def localize(self, top_n=1, mock=False) -> tuple[list, list, list, any]:
+        pass
+
+
+class LLMFL(FL):
+    obtain_relevant_files_prompt = """
+    Please look through the following GitHub problem description and Repository structure and provide a list of files that one would need to edit to fix the problem in a Verilog/SystemVerilog hardware design repository.
+
+    ### GitHub Problem Description ###
+    {problem_statement}
+
+    ###
+
+    ### Repository Structure ###
+    {structure}
+
+    ###
+
+    Please only provide the full path and return at most 5 files.
+    The returned files should be separated by new lines ordered by most to least important and wrapped with ```
+    For example:
+    rtl/top.sv
+    rtl/core/alu.sv
+    tb/top_tb.sv
+
+    """
+
+    obtain_irrelevant_files_prompt = """
+    Please look through the following GitHub problem description and Repository structure and provide a list of folders that are irrelevant to fixing the problem.
+    Note that irrelevant folders are those that do not need to be modified and are safe to ignore when trying to solve this problem.
+
+    ### GitHub Problem Description ###
+    {problem_statement}
+
+    ###
+
+    ### Repository Structure ###
+    {structure}
+
+    ###
+
+    Please only provide the full path.
+    Remember that any subfolders will be considered as irrelevant if you provide the parent folder.
+    Please ensure that the provided irrelevant folders do not include any important files needed to fix the problem (e.g., RTL, testbenches, constraints, build scripts, or verification collateral).
+    The returned folders should be separated by new lines and wrapped with ```
+    For example:
+    docs/
+    scripts/legacy/
+    third_party/
+
+    """
+
+    file_content_template = """
+    ### File: {file_name} ###
+    {file_content}
+    """
+
+    file_content_in_block_template = """
+    ### File: {file_name} ###
+    ```systemverilog
+    {file_content}
+    """
+
+    obtain_relevant_code_combine_top_n_prompt = """
+    Please review the following GitHub problem description and relevant files, and provide a set of locations that need to be edited to fix the issue in a Verilog/SystemVerilog codebase.
+    Locations may be specified as module names, interface names, package names, task/function names, parameter/localparam names, signal names, or exact line numbers requiring modification.
+
+    GitHub Problem Description
+    {problem_statement}
+
+    {file_contents}
+
+    Please provide the module/interface/package name, task/function name, parameter name, or the exact line numbers that need to be edited.
+    The possible location outputs should be either "module", "interface", "package", "function", "task", "parameter", "signal", or "line".
+
+    Examples:
+    rtl/top.sv
+    line: 42
+    module: top
+    line: 120
+
+    rtl/core/alu.sv
+    module: alu
+    function: compute_flags
+    line: 88
+
+    rtl/common/types_pkg.sv
+    package: types_pkg
+    parameter: XLEN
+    Return just the location(s) wrapped with ```.
+    """
+
+    obtain_relevant_code_combine_top_n_no_line_number_prompt = """
+    Please review the following GitHub problem description and relevant files, and provide a set of locations that need to be edited to fix the issue in a Verilog/SystemVerilog codebase.
+    Locations may be specified as module/interface/package names, task names, function names, parameters, or signals that require modification.
+
+    GitHub Problem Description
+    {problem_statement}
+
+    {file_contents}
+
+    Please provide the module/interface/package, task, function, parameter, or signal names that need to be edited.
+
+    Examples:
+    rtl/top.sv
+    module: top
+    signal: reset_n
+
+    rtl/core/alu.sv
+    module: alu
+    function: compute_flags
+    task: do_execute
+
+    rtl/common/types_pkg.sv
+    package: types_pkg
+    parameter: XLEN
+    Return just the location(s) wrapped with ```.
+    """
+
+    obtain_relevant_functions_and_vars_from_compressed_files_prompt_more = """
+    Please look through the following GitHub Problem Description and the Skeleton of Relevant Files.
+    Identify all locations that need inspection or editing to fix the problem in a Verilog/SystemVerilog repository, including directly related areas as well as any potentially related parameters, signals, modules, interfaces, packages, tasks, functions, and assertions.
+    For each location you provide, give the name of a module, interface, package, task, function, parameter/localparam, signal, or a named assertion/property/sequence.
+
+    GitHub Problem Description
+    {problem_statement}
+
+    Skeleton of Relevant Files
+    {file_contents}
+
+    Please provide the complete set of locations as either a module name, interface name, package name, task name, function name, parameter name, signal name, or assertion/property name.
+    Note that if you include a module/interface/package, you do not need to list its internal blocks unless you want to point to a specific task/function or named generate block.
+
+    Examples:
+    rtl/top.sv
+    module: top
+    signal: reset_n
+    parameter: BOOT_ADDR
+
+    rtl/core/pipe.sv
+    module: pipeline
+    function: compute_next_pc
+    task: flush_pipe
+    signal: stall
+
+    rtl/common/types_pkg.sv
+    package: types_pkg
+    parameter: XLEN
+    Return just the locations wrapped with ```.
+    """
+
+    obtain_relevant_functions_and_vars_from_raw_files_prompt = """
+    Please look through the following GitHub Problem Description and Relevant Files.
+    Identify all locations that need inspection or editing to fix the problem in a Verilog/SystemVerilog repository, including directly related areas as well as any potentially related parameters, signals, modules, interfaces, packages, tasks, functions, and assertions.
+    For each location you provide, give the name of a module, interface, package, task, function, parameter/localparam, signal, or a named assertion/property/sequence.
+
+    GitHub Problem Description
+    {problem_statement}
+
+    Relevant Files
+    {file_contents}
+
+    Please provide the complete set of locations as either a module name, interface name, package name, task name, function name, parameter name, signal name, or assertion/property name.
+    Note that if you include a module/interface/package, you do not need to list its internal blocks unless you want to point to a specific task/function or named generate block.
+
+    Examples:
+    rtl/top.sv
+    module: top
+    signal: reset_n
+    parameter: BOOT_ADDR
+
+    rtl/core/pipe.sv
+    module: pipeline
+    function: compute_next_pc
+    task: flush_pipe
+    signal: stall
+
+    rtl/common/types_pkg.sv
+    package: types_pkg
+    parameter: XLEN
+    Return just the locations wrapped with ```.
+    """
+
+    def __init__(
+        self,
+        instance_id,
+        structure,
+        problem_statement,
+        model_name,
+        backend,
+        logger,
+        **kwargs,
+    ):
+        super().__init__(instance_id, structure, problem_statement)
+        self.max_tokens = 300
+        self.model_name = model_name
+        self.backend = backend
+        self.logger = logger
+
+    def _parse_model_return_lines(self, content: str) -> list[str]:
+        if not content:
+            self.logger.error("Model returned empty response; cannot parse paths.")
+            return []
+        return content.strip().split("\n")
+
+    def localize_irrelevant(self, top_n=1, mock=False):
+        from agentless.util.api_requests import num_tokens_from_messages
+        from agentless.util.model import make_model
+
+        message = self.obtain_irrelevant_files_prompt.format(
+            problem_statement=self.problem_statement,
+            structure=show_project_structure(self.structure).strip(),
+        ).strip()
+        self.logger.info(f"prompting with message:\n{message}")
+        self.logger.info("=" * 80)
+
+        if mock:
+            self.logger.info("Skipping querying model since mock=True")
+            traj = {
+                "prompt": message,
+                "usage": {
+                    "prompt_tokens": num_tokens_from_messages(message, self.model),
+                },
+            }
+            return [], {"raw_output_loc": ""}, traj
+
+        model = make_model(
+            model=self.model_name,
+            backend=self.backend,
+            logger=self.logger,
+            max_tokens=2048,  # self.max_tokens,
+            temperature=0,
+            batch_size=1,
+        )
+        traj = model.codegen(message, num_samples=1)[0]
+        traj["prompt"] = message
+        raw_output = traj["response"]
+
+        files, classes, functions = get_full_file_paths_and_classes_and_functions(
+            self.structure
+        )
+
+        f_files = []
+        filtered_files = []
+
+        model_identified_files_folder = self._parse_model_return_lines(raw_output)
+        # remove any none folder none files
+        model_identified_files_folder = [
+            x
+            for x in model_identified_files_folder
+            if x.endswith("/") or x.endswith(".py")
+        ]
+
+        for file_content in files:
+            file_name = file_content[0]
+            if any([file_name.startswith(x) for x in model_identified_files_folder]):
+                filtered_files.append(file_name)
+            else:
+                f_files.append(file_name)
+
+        self.logger.info(raw_output)
+
+        return (
+            f_files,
+            {
+                "raw_output_files": raw_output,
+                "found_files": f_files,
+                "filtered_files": filtered_files,
+            },
+            traj,
+        )
+
+    def localize(self, top_n=1, mock=False) -> tuple[list, list, list, any]:
+        from agentless.util.api_requests import num_tokens_from_messages
+        from agentless.util.model import make_model
+
+        found_files = []
+
+        message = self.obtain_relevant_files_prompt.format(
+            problem_statement=self.problem_statement,
+            structure=show_project_structure(self.structure).strip(),
+        ).strip()
+        self.logger.info(f"prompting with message:\n{message}")
+        self.logger.info("=" * 80)
+        if mock:
+            self.logger.info("Skipping querying model since mock=True")
+            traj = {
+                "prompt": message,
+                "usage": {
+                    "prompt_tokens": num_tokens_from_messages(message, self.model_name),
+                },
+            }
+            return [], {"raw_output_loc": ""}, traj
+
+        model = make_model(
+            model=self.model_name,
+            backend=self.backend,
+            logger=self.logger,
+            max_tokens=self.max_tokens,
+            temperature=0,
+            batch_size=1,
+        )
+        traj = model.codegen(message, num_samples=1)[0]
+        traj["prompt"] = message
+        raw_output = traj["response"]
+        model_found_files = self._parse_model_return_lines(raw_output)
+
+        files, classes, functions = get_full_file_paths_and_classes_and_functions(
+            self.structure
+        )
+
+        # sort based on order of appearance in model_found_files
+        found_files = correct_file_paths(model_found_files, files)
+
+        self.logger.info(raw_output)
+
+        return (
+            found_files,
+            {"raw_output_files": raw_output},
+            traj,
+        )
+
+    def localize_function_from_compressed_files(
+        self,
+        file_names,
+        mock=False,
+        temperature=0.0,
+        keep_old_order=False,
+        compress_assign: bool = False,
+        total_lines=30,
+        prefix_lines=10,
+        suffix_lines=10,
+    ):
+        from agentless.util.api_requests import num_tokens_from_messages
+        from agentless.util.model import make_model
+
+        file_contents = get_repo_files(self.structure, file_names)
+        compressed_file_contents = {
+            fn: get_skeleton(
+                code,
+                compress_assign=compress_assign,
+                total_lines=total_lines,
+                prefix_lines=prefix_lines,
+                suffix_lines=suffix_lines,
+            )
+            for fn, code in file_contents.items()
+        }
+        contents = [
+            self.file_content_in_block_template.format(file_name=fn, file_content=code)
+            for fn, code in compressed_file_contents.items()
+        ]
+        file_contents = "".join(contents)
+        template = (
+            self.obtain_relevant_functions_and_vars_from_compressed_files_prompt_more
+        )
+        message = template.format(
+            problem_statement=self.problem_statement, file_contents=file_contents
+        )
+        self.logger.info(f"prompting with message:")
+        self.logger.info("\n" + message)
+
+        def message_too_long(message):
+            return (
+                num_tokens_from_messages(message, self.model_name) >= MAX_CONTEXT_LENGTH
+            )
+
+        while message_too_long(message) and len(contents) > 1:
+            self.logger.info(f"reducing to \n{len(contents)} files")
+            contents = contents[:-1]
+            file_contents = "".join(contents)
+            message = template.format(
+                problem_statement=self.problem_statement, file_contents=file_contents
+            )  # Recreate message
+
+        if message_too_long(message):
+            raise ValueError(
+                "The remaining file content is too long to fit within the context length"
+            )
+        self.logger.info(f"prompting with message:\n{message}")
+        self.logger.info("=" * 80)
+
+        if mock:
+            self.logger.info("Skipping querying model since mock=True")
+            traj = {
+                "prompt": message,
+                "usage": {
+                    "prompt_tokens": num_tokens_from_messages(
+                        message,
+                        self.model_name,
+                    ),
+                },
+            }
+            return {}, {"raw_output_loc": ""}, traj
+
+        model = make_model(
+            model=self.model_name,
+            backend=self.backend,
+            logger=self.logger,
+            max_tokens=self.max_tokens,
+            temperature=temperature,
+            batch_size=1,
+        )
+        traj = model.codegen(message, num_samples=1)[0]
+        traj["prompt"] = message
+        raw_output = traj["response"]
+
+        model_found_locs = extract_code_blocks(raw_output)
+        model_found_locs_separated = extract_locs_for_files(
+            model_found_locs, file_names, keep_old_order
+        )
+
+        self.logger.info(f"==== raw output ====")
+        self.logger.info(raw_output)
+        self.logger.info("=" * 80)
+        self.logger.info(f"==== extracted locs ====")
+        for loc in model_found_locs_separated:
+            self.logger.info(loc)
+        self.logger.info("=" * 80)
+
+        return model_found_locs_separated, {"raw_output_loc": raw_output}, traj
+
+    def localize_function_from_raw_text(
+        self,
+        file_names,
+        mock=False,
+        temperature=0.0,
+        keep_old_order=False,
+    ):
+        from agentless.util.api_requests import num_tokens_from_messages
+        from agentless.util.model import make_model
+
+        file_contents = get_repo_files(self.structure, file_names)
+        raw_file_contents = {fn: code for fn, code in file_contents.items()}
+        contents = [
+            self.file_content_template.format(file_name=fn, file_content=code)
+            for fn, code in raw_file_contents.items()
+        ]
+        file_contents = "".join(contents)
+        template = self.obtain_relevant_functions_and_vars_from_raw_files_prompt
+        message = template.format(
+            problem_statement=self.problem_statement, file_contents=file_contents
+        )
+        self.logger.info(f"prompting with message:")
+        self.logger.info("\n" + message)
+
+        def message_too_long(message):
+            return (
+                num_tokens_from_messages(message, self.model_name) >= MAX_CONTEXT_LENGTH
+            )
+
+        while message_too_long(message) and len(contents) > 1:
+            self.logger.info(f"reducing to \n{len(contents)} files")
+            contents = contents[:-1]
+            file_contents = "".join(contents)
+            message = template.format(
+                problem_statement=self.problem_statement, file_contents=file_contents
+            )  # Recreate message
+
+        if message_too_long(message):
+            raise ValueError(
+                "The remaining file content is too long to fit within the context length"
+            )
+        self.logger.info(f"prompting with message:\n{message}")
+        self.logger.info("=" * 80)
+
+        if mock:
+            self.logger.info("Skipping querying model since mock=True")
+            traj = {
+                "prompt": message,
+                "usage": {
+                    "prompt_tokens": num_tokens_from_messages(
+                        message,
+                        self.model_name,
+                    ),
+                },
+            }
+            return {}, {"raw_output_loc": ""}, traj
+
+        model = make_model(
+            model=self.model_name,
+            backend=self.backend,
+            logger=self.logger,
+            max_tokens=self.max_tokens,
+            temperature=temperature,
+            batch_size=1,
+        )
+        traj = model.codegen(message, num_samples=1)[0]
+        traj["prompt"] = message
+        raw_output = traj["response"]
+
+        model_found_locs = extract_code_blocks(raw_output)
+        model_found_locs_separated = extract_locs_for_files(
+            model_found_locs, file_names, keep_old_order
+        )
+
+        self.logger.info(f"==== raw output ====")
+        self.logger.info(raw_output)
+        self.logger.info("=" * 80)
+        self.logger.info(f"==== extracted locs ====")
+        for loc in model_found_locs_separated:
+            self.logger.info(loc)
+        self.logger.info("=" * 80)
+
+        return model_found_locs_separated, {"raw_output_loc": raw_output}, traj
+
+    def localize_line_from_coarse_function_locs(
+        self,
+        file_names,
+        coarse_locs,
+        context_window: int,
+        add_space: bool,
+        sticky_scroll: bool,
+        no_line_number: bool,
+        temperature: float = 0.0,
+        num_samples: int = 1,
+        mock=False,
+        keep_old_order=False,
+    ):
+        from agentless.util.api_requests import num_tokens_from_messages
+        from agentless.util.model import make_model
+
+        file_contents = get_repo_files(self.structure, file_names)
+        topn_content, file_loc_intervals = construct_topn_file_context(
+            coarse_locs,
+            file_names,
+            file_contents,
+            self.structure,
+            context_window=context_window,
+            loc_interval=True,
+            add_space=add_space,
+            sticky_scroll=sticky_scroll,
+            no_line_number=no_line_number,
+        )
+        if no_line_number:
+            template = self.obtain_relevant_code_combine_top_n_no_line_number_prompt
+        else:
+            template = self.obtain_relevant_code_combine_top_n_prompt
+        message = template.format(
+            problem_statement=self.problem_statement, file_contents=topn_content
+        )
+        self.logger.info(f"prompting with message:\n{message}")
+        self.logger.info("=" * 80)
+
+        def message_too_long(message):
+            return (
+                num_tokens_from_messages(message, self.model_name) >= MAX_CONTEXT_LENGTH
+            )
+
+        while message_too_long(message) and len(coarse_locs) > 1:
+            self.logger.info(f"reducing to \n{len(coarse_locs)} files")
+            coarse_locs.popitem()
+            topn_content, file_loc_intervals = construct_topn_file_context(
+                coarse_locs,
+                file_names,
+                file_contents,
+                self.structure,
+                context_window=context_window,
+                loc_interval=True,
+                add_space=add_space,
+                sticky_scroll=sticky_scroll,
+                no_line_number=no_line_number,
+            )
+            message = template.format(
+                problem_statement=self.problem_statement, file_contents=topn_content
+            )
+
+        if message_too_long(message):
+            raise ValueError(
+                "The remaining file content is too long to fit within the context length"
+            )
+
+        if mock:
+            self.logger.info("Skipping querying model since mock=True")
+            traj = {
+                "prompt": message,
+                "usage": {
+                    "prompt_tokens": num_tokens_from_messages(message, self.model_name),
+                },
+            }
+            return [], {"raw_output_loc": ""}, traj
+
+        model = make_model(
+            model=self.model_name,
+            backend=self.backend,
+            logger=self.logger,
+            max_tokens=self.max_tokens,
+            temperature=temperature,
+            batch_size=num_samples,
+        )
+        raw_trajs = model.codegen(
+            message, num_samples=num_samples, prompt_cache=num_samples > 1
+        )
+
+        # Merge trajectories
+        raw_outputs = [raw_traj["response"] for raw_traj in raw_trajs]
+        traj = {
+            "prompt": message,
+            "response": raw_outputs,
+            "usage": {  # merge token usage
+                "completion_tokens": sum(
+                    raw_traj["usage"]["completion_tokens"] for raw_traj in raw_trajs
+                ),
+                "prompt_tokens": sum(
+                    raw_traj["usage"]["prompt_tokens"] for raw_traj in raw_trajs
+                ),
+            },
+        }
+        model_found_locs_separated_in_samples = []
+        for raw_output in raw_outputs:
+            model_found_locs = extract_code_blocks(raw_output)
+            model_found_locs_separated = extract_locs_for_files(
+                model_found_locs, file_names, keep_old_order
+            )
+            model_found_locs_separated_in_samples.append(model_found_locs_separated)
+
+            self.logger.info(f"==== raw output ====")
+            self.logger.info(raw_output)
+            self.logger.info("=" * 80)
+            self.logger.info(f"==== extracted locs ====")
+            for loc in model_found_locs_separated:
+                self.logger.info(loc)
+            self.logger.info("=" * 80)
+        self.logger.info("==== Input coarse_locs")
+        coarse_info = ""
+        for fn, found_locs in coarse_locs.items():
+            coarse_info += f"### {fn}\n"
+            if isinstance(found_locs, str):
+                coarse_info += found_locs + "\n"
+            else:
+                coarse_info += "\n".join(found_locs) + "\n"
+        self.logger.info("\n" + coarse_info)
+        if len(model_found_locs_separated_in_samples) == 1:
+            model_found_locs_separated_in_samples = (
+                model_found_locs_separated_in_samples[0]
+            )
+
+        return (
+            model_found_locs_separated_in_samples,
+            {"raw_output_loc": raw_outputs},
+            traj,
+        )
+
+    def localize_line_from_raw_text(
+        self,
+        file_names,
+        mock=False,
+        temperature=0.0,
+        num_samples=1,
+        keep_old_order=False,
+    ):
+        from agentless.util.api_requests import num_tokens_from_messages
+        from agentless.util.model import make_model
+
+        file_contents = get_repo_files(self.structure, file_names)
+        raw_file_contents = {
+            fn: line_wrap_content(code) for fn, code in file_contents.items()
+        }
+        contents = [
+            self.file_content_template.format(file_name=fn, file_content=code)
+            for fn, code in raw_file_contents.items()
+        ]
+        file_contents = "".join(contents)
+        template = self.obtain_relevant_code_combine_top_n_prompt
+        message = template.format(
+            problem_statement=self.problem_statement, file_contents=file_contents
+        )
+        self.logger.info(f"prompting with message:")
+        self.logger.info("\n" + message)
+
+        def message_too_long(message):
+            return (
+                num_tokens_from_messages(message, self.model_name) >= MAX_CONTEXT_LENGTH
+            )
+
+        while message_too_long(message) and len(contents) > 1:
+            self.logger.info(f"reducing to \n{len(contents)} files")
+            contents = contents[:-1]
+            file_contents = "".join(contents)
+            message = template.format(
+                problem_statement=self.problem_statement, file_contents=file_contents
+            )  # Recreate message
+
+        if message_too_long(message):
+            raise ValueError(
+                "The remaining file content is too long to fit within the context length"
+            )
+        self.logger.info(f"prompting with message:\n{message}")
+        self.logger.info("=" * 80)
+
+        if mock:
+            self.logger.info("Skipping querying model since mock=True")
+            traj = {
+                "prompt": message,
+                "usage": {
+                    "prompt_tokens": num_tokens_from_messages(
+                        message,
+                        self.model_name,
+                    ),
+                },
+            }
+            return {}, {"raw_output_loc": ""}, traj
+
+        model = make_model(
+            model=self.model_name,
+            backend=self.backend,
+            logger=self.logger,
+            max_tokens=self.max_tokens,
+            temperature=temperature,
+            batch_size=num_samples,
+        )
+        raw_trajs = model.codegen(message, num_samples=num_samples)
+
+        # Merge trajectories
+        raw_outputs = [raw_traj["response"] for raw_traj in raw_trajs]
+        traj = {
+            "prompt": message,
+            "response": raw_outputs,
+            "usage": {  # merge token usage
+                "completion_tokens": sum(
+                    raw_traj["usage"]["completion_tokens"] for raw_traj in raw_trajs
+                ),
+                "prompt_tokens": sum(
+                    raw_traj["usage"]["prompt_tokens"] for raw_traj in raw_trajs
+                ),
+            },
+        }
+        model_found_locs_separated_in_samples = []
+        for raw_output in raw_outputs:
+            model_found_locs = extract_code_blocks(raw_output)
+            model_found_locs_separated = extract_locs_for_files(
+                model_found_locs, file_names, keep_old_order
+            )
+            model_found_locs_separated_in_samples.append(model_found_locs_separated)
+
+            self.logger.info(f"==== raw output ====")
+            self.logger.info(raw_output)
+            self.logger.info("=" * 80)
+            self.logger.info(f"==== extracted locs ====")
+            for loc in model_found_locs_separated:
+                self.logger.info(loc)
+            self.logger.info("=" * 80)
+
+        if len(model_found_locs_separated_in_samples) == 1:
+            model_found_locs_separated_in_samples = (
+                model_found_locs_separated_in_samples[0]
+            )
+
+        return (
+            model_found_locs_separated_in_samples,
+            {"raw_output_loc": raw_outputs},
+            traj,
+        )

Repos/HWE/agents/Agentless/agentless/fl/Index.py

@@ -0,0 +1,333 @@
+import copy
+import os
+from abc import ABC
+
+import tiktoken
+from llama_index.core import (
+    Document,
+    MockEmbedding,
+    Settings,
+    StorageContext,
+    VectorStoreIndex,
+    load_index_from_storage,
+)
+from llama_index.core.callbacks import CallbackManager, TokenCountingHandler
+from llama_index.core.retrievers import VectorIndexRetriever
+from llama_index.core.schema import MetadataMode
+from llama_index.embeddings.openai import OpenAIEmbedding
+
+from agentless.util.api_requests import num_tokens_from_messages
+from agentless.util.preprocess_data import (
+    clean_method_left_space,
+    get_full_file_paths_and_classes_and_functions,
+)
+try:
+    from get_repo_structure.get_repo_structure import parse_verilog_file as parse_source_file
+except ImportError:
+    from get_repo_structure.get_repo_structure import parse_python_file as parse_source_file
+
+VERILOG_EXTENSIONS = {".v", ".sv", ".vh", ".svh"}
+
+
+def _is_verilog_path(file_name: str) -> bool:
+    _, ext = os.path.splitext(file_name)
+    return ext.lower() in VERILOG_EXTENSIONS
+
+
+def _parse_global_stmt(file_content: str, file_name: str) -> tuple[str, str]:
+    if _is_verilog_path(file_name):
+        return "", ""
+    try:
+        from agentless.util.index_skeleton import parse_global_stmt_from_code
+    except Exception:
+        return "", ""
+    return parse_global_stmt_from_code(file_content)
+
+
+def construct_file_meta_data(file_name: str, clazzes: list, functions: list) -> dict:
+    meta_data = {
+        "file_name": file_name,
+    }
+    meta_data["File Name"] = file_name
+
+    if clazzes:
+        class_names = ", ".join([c["name"] for c in clazzes])
+        meta_data["Classes"] = class_names
+        if _is_verilog_path(file_name):
+            meta_data["Modules"] = class_names
+    if functions:
+        function_names = ", ".join([f["name"] for f in functions])
+        meta_data["Functions"] = function_names
+        if _is_verilog_path(file_name):
+            meta_data["Tasks/Functions"] = function_names
+
+    return meta_data
+
+
+def check_meta_data(meta_data: dict) -> bool:
+
+    doc = Document(
+        text="",
+        metadata=meta_data,
+        metadata_template="### {key}: {value}",
+        text_template="Metadata:\n{metadata_str}\n-----\nCode:\n{content}",
+    )
+
+    if (
+        num_tokens_from_messages(
+            doc.get_content(metadata_mode=MetadataMode.EMBED),
+            model="text-embedding-3-small",
+        )
+        > Settings.chunk_size // 2
+    ):
+        # half of the chunk size should not be metadata
+        return False
+
+    return True
+
+
+def build_file_documents_simple(
+    clazzes: list, functions: list, file_name: str, file_content: str
+) -> list[Document]:
+    """
+    Really simple file document format, where we put all content of a single file into a single document
+    """
+    documents = []
+
+    meta_data = construct_file_meta_data(file_name, clazzes, functions)
+
+    doc = Document(
+        text=file_content,
+        metadata=meta_data,
+        metadata_template="### {key}: {value}",
+        text_template="Metadata:\n{metadata_str}\n-----\nCode:\n{content}",
+    )
+    doc.excluded_embed_metadata_keys = ["file_name"]  # used for searching only.
+    doc.excluded_llm_metadata_keys = ["file_name"]  # used for searching only.
+    if not check_meta_data(meta_data):
+        # meta_data a bit too long, instead we just exclude meta data
+        doc.excluded_embed_metadata_keys = list(meta_data.keys())
+        doc.excluded_llm_metadata_keys = list(meta_data.keys())
+        documents.append(doc)
+    else:
+        documents.append(doc)
+
+    return documents
+
+
+def build_file_documents_complex(
+    clazzes: list, functions: list, file_name: str, file_content: str
+) -> list[Document]:
+
+    documents = []
+
+    global_stmt, _ = _parse_global_stmt(file_content, file_name)
+    base_meta_data = construct_file_meta_data(file_name, clazzes, functions)
+    is_verilog = _is_verilog_path(file_name)
+
+    for clazz in clazzes:
+        content = "\n".join(clazz["text"])
+        meta_data = copy.deepcopy(base_meta_data)
+        meta_data["Class Name"] = clazz["name"]
+        if is_verilog:
+            meta_data["Module Name"] = clazz["name"]
+        doc = Document(
+            text=content,
+            metadata=meta_data,
+            metadata_template="### {key}: {value}",
+            text_template="Metadata:\n{metadata_str}\n-----\nCode:\n{content}",
+        )
+
+        doc.excluded_embed_metadata_keys = ["file_name"]  # used for searching only.
+        doc.excluded_llm_metadata_keys = ["file_name"]  # used for searching only.
+        if not check_meta_data(meta_data):
+            doc.excluded_embed_metadata_keys = list(meta_data.keys())
+            doc.excluded_llm_metadata_keys = list(meta_data.keys())
+        documents.append(doc)
+
+        for class_method in clazz["methods"]:
+            method_meta_data = copy.deepcopy(base_meta_data)
+            method_meta_data["Class Name"] = clazz["name"]
+            method_meta_data["Method Name"] = class_method["name"]
+            if is_verilog:
+                method_meta_data["Task/Function Name"] = class_method["name"]
+            content = clean_method_left_space("\n".join(class_method["text"]))
+
+            doc = Document(
+                text=content,
+                metadata=method_meta_data,
+                metadata_template="### {key}: {value}",
+                text_template="Metadata:\n{metadata_str}\n-----\nCode:\n{content}",
+            )
+            doc.excluded_embed_metadata_keys = ["file_name"]  # used for searching only.
+            doc.excluded_llm_metadata_keys = ["file_name"]  # used for searching only.
+            if not check_meta_data(method_meta_data):
+                doc.excluded_embed_metadata_keys = list(method_meta_data.keys())
+                doc.excluded_llm_metadata_keys = list(method_meta_data.keys())
+            documents.append(doc)
+
+    for function in functions:
+        content = "\n".join(function["text"])
+        function_meta_data = copy.deepcopy(base_meta_data)
+        function_meta_data["Function Name"] = function["name"]
+        if is_verilog:
+            function_meta_data["Task/Function Name"] = function["name"]
+        doc = Document(
+            text=content,
+            metadata=function_meta_data,
+            metadata_template="### {key}: {value}",
+            text_template="Metadata:\n{metadata_str}\n-----\nCode:\n{content}",
+        )
+
+        doc.excluded_embed_metadata_keys = ["file_name"]  # used for searching only.
+        doc.excluded_llm_metadata_keys = ["file_name"]  # used for searching only.
+        if not check_meta_data(function_meta_data):
+            doc.excluded_embed_metadata_keys = list(function_meta_data.keys())
+            doc.excluded_llm_metadata_keys = list(function_meta_data.keys())
+        documents.append(doc)
+
+    if global_stmt != "":
+        content = global_stmt
+        global_meta_data = copy.deepcopy(base_meta_data)
+
+        doc = Document(
+            text=content,
+            metadata=global_meta_data,
+            metadata_template="### {key}: {value}",
+            text_template="Metadata:\n{metadata_str}\n-----\nCode:\n{content}",
+        )
+        doc.excluded_embed_metadata_keys = ["file_name"]  # used for searching only.
+        doc.excluded_llm_metadata_keys = ["file_name"]  # used for searching only.
+        if not check_meta_data(global_meta_data):
+            doc.excluded_embed_metadata_keys = list(global_meta_data.keys())
+            doc.excluded_llm_metadata_keys = list(global_meta_data.keys())
+        documents.append(doc)
+
+    return documents
+
+
+class EmbeddingIndex(ABC):
+    def __init__(
+        self,
+        instance_id,
+        structure,
+        problem_statement,
+        persist_dir,
+        filter_type,
+        index_type,
+        chunk_size,
+        chunk_overlap,
+        logger,
+        **kwargs,
+    ):
+        self.instance_id = instance_id
+        self.structure = structure
+        self.problem_statement = problem_statement
+        self.persist_dir = persist_dir + "/{instance_id}"
+        self.filter_type = filter_type
+        self.index_type = index_type
+        self.chunk_size = chunk_size
+        self.chunk_overlap = chunk_overlap
+        self.logger = logger
+        self.kwargs = kwargs
+        # set some embedding global settings.
+
+        Settings.chunk_size = chunk_size
+        Settings.chunk_overlap = chunk_overlap
+
+    def filter_files(self, files):
+        if self.filter_type == "given_files":
+            given_files = self.kwargs["given_files"][: self.kwargs["filter_top_n"]]
+            return given_files
+        elif self.filter_type == "none":
+            # all files are included
+            return [file_content[0] for file_content in files]
+        else:
+            raise NotImplementedError
+
+    def retrieve(self, mock=False):
+
+        persist_dir = self.persist_dir.format(instance_id=self.instance_id)
+        token_counter = TokenCountingHandler(
+            tokenizer=tiktoken.encoding_for_model("text-embedding-3-small").encode
+        )
+        if not os.path.exists(persist_dir) or mock:
+            files, _, _ = get_full_file_paths_and_classes_and_functions(self.structure)
+            filtered_files = self.filter_files(files)
+            self.logger.info(f"Total number of considered files: {len(filtered_files)}")
+            print(f"Total number of considered files: {len(filtered_files)}")
+            documents = []
+
+            for file_content in files:
+                content = "\n".join(file_content[1])
+                file_name = file_content[0]
+
+                if file_name not in filtered_files:
+                    continue
+
+                # create documents
+                class_info, function_names, _ = parse_source_file(None, content)
+                if self.index_type == "simple":
+                    docs = build_file_documents_simple(
+                        class_info, function_names, file_name, content
+                    )
+                elif self.index_type == "complex":
+                    docs = build_file_documents_complex(
+                        class_info, function_names, file_name, content
+                    )
+                else:
+                    raise NotImplementedError
+
+                documents.extend(docs)
+
+            self.logger.info(f"Total number of documents: {len(documents)}")
+            print(f"Total number of documents: {len(documents)}")
+
+            if mock:
+                embed_model = MockEmbedding(
+                    embed_dim=1024
+                )  # embedding dimension does not matter for mocking.
+                Settings.callback_manager = CallbackManager([token_counter])
+            else:
+                embed_model = OpenAIEmbedding(model_name="text-embedding-3-small")
+            index = VectorStoreIndex.from_documents(documents, embed_model=embed_model)
+            index.storage_context.persist(persist_dir=persist_dir)
+        else:
+            storage_context = StorageContext.from_defaults(persist_dir=persist_dir)
+            index = load_index_from_storage(storage_context)
+
+        self.logger.info(f"Retrieving with query:\n{self.problem_statement}")
+
+        retriever = VectorIndexRetriever(index=index, similarity_top_k=100)
+        documents = retriever.retrieve(self.problem_statement)
+
+        self.logger.info(
+            f"Embedding Tokens: {token_counter.total_embedding_token_count}"
+        )
+        print(f"Embedding Tokens: {token_counter.total_embedding_token_count}")
+
+        traj = {
+            "usage": {"embedding_tokens": token_counter.total_embedding_token_count}
+        }
+
+        token_counter.reset_counts()
+
+        if mock:
+            self.logger.info("Skipping since mock=True")
+            return [], None, traj
+
+        file_names = []
+        meta_infos = []
+
+        for node in documents:
+            file_name = node.node.metadata["File Name"]
+            if file_name not in file_names:
+                file_names.append(file_name)
+                self.logger.info("================")
+                self.logger.info(file_name)
+
+            self.logger.info(node.node.text)
+
+            meta_infos.append({"code": node.node.text, "metadata": node.node.metadata})
+
+        return file_names, meta_infos, traj

Repos/HWE/agents/Agentless/agentless/fl/combine.py

@@ -0,0 +1,82 @@
+import argparse
+import json
+import os
+from collections import Counter
+
+from tqdm import tqdm
+
+from agentless.util.utils import load_jsonl
+
+
+def combine_file_level(args):
+
+    embed_used_locs = load_jsonl(args.retrieval_loc_file)
+    model_used_locs = load_jsonl(args.model_loc_file)
+
+    with open(f"{args.output_folder}/embed_used_locs.jsonl", "w") as f:
+        for loc in embed_used_locs:
+            f.write(json.dumps(loc) + "\n")
+
+    with open(f"{args.output_folder}/model_used_locs.jsonl", "w") as f:
+        for loc in model_used_locs:
+            f.write(json.dumps(loc) + "\n")
+
+    for pred in tqdm(model_used_locs, colour="MAGENTA"):
+        instance_id = pred["instance_id"]
+
+        model_loc = pred["found_files"]
+        retrieve_loc = [x for x in embed_used_locs if x["instance_id"] == instance_id][
+            0
+        ]["found_files"]
+
+        combined_loc_counter = Counter()
+        combined_locs = []
+
+        for loc in model_loc[: args.top_n]:
+            combined_loc_counter[loc] += 1
+
+        for loc in retrieve_loc[: args.top_n]:
+            combined_loc_counter[loc] += 1
+
+        combined_locs = [loc for loc, _ in combined_loc_counter.most_common()]
+
+        with open(args.output_file, "a") as f:
+            f.write(
+                json.dumps(
+                    {
+                        "instance_id": instance_id,
+                        "found_files": combined_locs,
+                        "additional_artifact_loc_file": {},
+                        "file_traj": {},
+                    }
+                )
+                + "\n"
+            )
+
+
+def main():
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument("--output_folder", type=str, required=True)
+    parser.add_argument("--output_file", type=str, default="combined_locs.jsonl")
+    parser.add_argument("--retrieval_loc_file", type=str, required=True)
+    parser.add_argument("--model_loc_file", type=str, required=True)
+    # supports file level (step-1) combination
+    parser.add_argument("--top_n", type=int, required=True)
+
+    args = parser.parse_args()
+
+    args.output_file = os.path.join(args.output_folder, args.output_file)
+    assert not os.path.exists(args.output_file), "Output file already exists"
+
+    os.makedirs(args.output_folder, exist_ok=True)
+
+    # dump argument
+    with open(os.path.join(args.output_folder, "args.json"), "w") as f:
+        json.dump(vars(args), f, indent=4)
+
+    combine_file_level(args)
+
+
+if __name__ == "__main__":
+    main()

Repos/HWE/agents/Agentless/agentless/fl/localize.py

@@ -0,0 +1,680 @@
+import argparse
+import concurrent.futures
+import json
+import os
+from threading import Lock
+
+from datasets import load_dataset
+from tqdm import tqdm
+
+from agentless.fl.FL import LLMFL
+from agentless.util.preprocess_data import (
+    check_contains_valid_loc,
+    filter_non_source,
+    filter_out_test_files,
+    get_repo_structure,
+)
+from agentless.util.utils import load_existing_instance_ids, load_jsonl, setup_logger
+
+MAX_RETRIES = 5
+HDL_EXTENSIONS = {".v", ".sv", ".vh", ".svh"}
+
+
+def _filter_hdl_files(files):
+    return [
+        file
+        for file in files
+        if os.path.splitext(file)[1].lower() in HDL_EXTENSIONS
+    ]
+
+
+def _filter_loc_dict(locs, allowed_files):
+    if not isinstance(locs, dict):
+        return locs
+    return {file: loc for file, loc in locs.items() if file in allowed_files}
+
+
+def _filter_edit_locs(edit_locs, allowed_files):
+    if isinstance(edit_locs, list):
+        return [
+            _filter_loc_dict(loc, allowed_files) if isinstance(loc, dict) else loc
+            for loc in edit_locs
+        ]
+    if isinstance(edit_locs, dict):
+        return _filter_loc_dict(edit_locs, allowed_files)
+    return edit_locs
+
+
+def load_bench_data(args):
+    if args.dataset_path:
+        if args.dataset_path.endswith(".jsonl"):
+            return load_jsonl(args.dataset_path)
+        if args.dataset_path.endswith(".json"):
+            with open(args.dataset_path, "r") as f:
+                return json.load(f)
+        raise ValueError("Unsupported dataset_path; use .json or .jsonl")
+    return load_dataset(args.dataset, split=args.dataset_split)
+
+
+def localize_irrelevant_instance(
+    bug, args, swe_bench_data, existing_instance_ids, write_lock=None
+):
+    instance_id = bug["instance_id"]
+    log_file = os.path.join(
+        args.output_folder, "localization_logs", f"{instance_id}.log"
+    )
+    if args.target_id is not None:
+        if args.target_id != bug["instance_id"]:
+            return
+
+    logger = setup_logger(log_file)
+    logger.info(f"Processing bug {instance_id}")
+
+    if bug["instance_id"] in existing_instance_ids:
+        logger.info(f"Skipping existing instance_id: {bug['instance_id']}")
+        return
+
+    logger.info(f"================ localize {instance_id} ================")
+
+    bench_data = [x for x in swe_bench_data if x["instance_id"] == instance_id][0]
+    problem_statement = bench_data["problem_statement"]
+    structure = get_repo_structure(
+        instance_id, bug["repo"], bug["base_commit"], "playground"
+    )
+
+    filter_non_source(structure)  # some basic filtering steps
+    filter_out_test_files(structure)
+
+    found_files = []
+    found_related_locs = {}
+    found_edit_locs = {}
+
+    additional_artifact_loc_file = None
+    additional_artifact_loc_related = None
+    additional_artifact_loc_edit_location = None
+    file_traj, related_loc_traj, edit_loc_traj = {}, {}, {}
+
+    # file level localization
+    if args.file_level:
+        fl = LLMFL(
+            instance_id,
+            structure,
+            problem_statement,
+            args.model,
+            args.backend,
+            logger,
+        )
+        found_files, additional_artifact_loc_file, file_traj = fl.localize_irrelevant(
+            mock=args.mock
+        )
+        found_files = _filter_hdl_files(found_files)
+    else:
+        raise NotImplementedError
+
+    if write_lock is not None:
+        write_lock.acquire()
+    allowed_files = set(found_files)
+    found_related_locs = _filter_loc_dict(found_related_locs, allowed_files)
+    found_edit_locs = _filter_edit_locs(found_edit_locs, allowed_files)
+    with open(args.output_file, "a") as f:
+        f.write(
+            json.dumps(
+                {
+                    "instance_id": instance_id,
+                    "found_files": found_files,
+                    "additional_artifact_loc_file": additional_artifact_loc_file,
+                    "file_traj": file_traj,
+                    "found_related_locs": found_related_locs,
+                    "additional_artifact_loc_related": additional_artifact_loc_related,
+                    "related_loc_traj": related_loc_traj,
+                    "found_edit_locs": found_edit_locs,
+                    "additional_artifact_loc_edit_location": additional_artifact_loc_edit_location,
+                    "edit_loc_traj": edit_loc_traj,
+                }
+            )
+            + "\n"
+        )
+    if write_lock is not None:
+        write_lock.release()
+
+
+def localize_instance(
+    bug, args, swe_bench_data, start_file_locs, existing_instance_ids, write_lock=None
+):
+    instance_id = bug["instance_id"]
+    log_file = os.path.join(
+        args.output_folder, "localization_logs", f"{instance_id}.log"
+    )
+    if args.target_id is not None:
+        if args.target_id != bug["instance_id"]:
+            return
+
+    logger = setup_logger(log_file)
+    logger.info(f"Processing bug {instance_id}")
+
+    if instance_id in existing_instance_ids:
+        logger.info(f"Skipping existing instance_id: {bug['instance_id']}")
+        return
+
+    structure = get_repo_structure(
+        instance_id, bug["repo"], bug["base_commit"], "playground"
+    )
+
+    logger.info(f"================ localize {instance_id} ================")
+
+    bench_data = [x for x in swe_bench_data if x["instance_id"] == instance_id][0]
+    problem_statement = bench_data["problem_statement"]
+
+    filter_non_source(structure)  # some basic filtering steps
+    filter_out_test_files(structure)
+
+    found_files = []
+    found_related_locs = {}
+    found_edit_locs = {}
+    additional_artifact_loc_file = None
+    additional_artifact_loc_related = None
+    additional_artifact_loc_edit_location = None
+    file_traj, related_loc_trajs, edit_loc_traj = {}, [], {}
+
+    # file level localization
+    if args.file_level:
+        fl = LLMFL(
+            instance_id,
+            structure,
+            problem_statement,
+            args.model,
+            args.backend,
+            logger,
+        )
+        found_files, additional_artifact_loc_file, file_traj = fl.localize(
+            mock=args.mock
+        )
+        found_files = _filter_hdl_files(found_files)
+    else:
+        # assume start_file is provided
+        for locs in start_file_locs:
+            if locs["instance_id"] == instance_id:
+                found_files = locs["found_files"]
+                if "additional_artifact_loc_file" in locs:
+                    additional_artifact_loc_file = locs["additional_artifact_loc_file"]
+                    file_traj = locs["file_traj"]
+                if "found_related_locs" in locs:
+                    found_related_locs = locs["found_related_locs"]
+                    additional_artifact_loc_related = locs[
+                        "additional_artifact_loc_related"
+                    ]
+                    related_loc_trajs = locs["related_loc_traj"]
+                break
+
+        found_files = _filter_hdl_files(found_files)
+        allowed_files = set(found_files)
+        found_related_locs = _filter_loc_dict(found_related_locs, allowed_files)
+
+        if len(found_files) == 0:
+            return
+
+    # related class, functions, global var localization
+    if args.related_level:
+        if len(found_files) != 0:
+            trying_temp = 0  # related always try with temp 0
+            related_loc_trajs = []
+            for _ in range(MAX_RETRIES):
+                pred_files = found_files[: args.top_n]
+                fl = LLMFL(
+                    instance_id,
+                    structure,
+                    problem_statement,
+                    args.model,
+                    args.backend,
+                    logger,
+                )
+                additional_artifact_loc_related = []
+                found_related_locs = {}
+                related_loc_traj = {}
+                if args.compress and not args.related_level_separate_file:
+                    (
+                        found_related_locs,
+                        additional_artifact_loc_related,
+                        related_loc_traj,
+                    ) = fl.localize_function_from_compressed_files(
+                        pred_files,
+                        mock=args.mock,
+                        temperature=trying_temp,
+                        keep_old_order=args.keep_old_order,
+                        compress_assign=args.compress_assign,
+                        total_lines=args.compress_assign_total_lines,
+                        prefix_lines=args.compress_assign_prefix_lines,
+                        suffix_lines=args.compress_assign_suffix_lines,
+                    )
+                    additional_artifact_loc_related = [additional_artifact_loc_related]
+                    related_loc_trajs.append(related_loc_traj)
+
+                    if check_contains_valid_loc(
+                        found_related_locs, structure=structure
+                    ):
+                        break
+
+                    logger.info(
+                        f"No valid related locations found ... retrying with higher temperature ..."
+                    )
+                    trying_temp = 1.0  # set trying temp to 1 to get valid locs
+
+                elif args.compress and args.related_level_separate_file:
+                    additional_artifact_loc_related = []
+                    found_related_locs = {fn: [] for fn in pred_files}
+                    related_loc_traj = []
+                    for i, pred_file in enumerate(pred_files):
+                        (
+                            found_related_locs_i,
+                            additional_artifact_loc_related_i,
+                            related_loc_traj_i,
+                        ) = fl.localize_function_from_compressed_files(
+                            [pred_file],
+                            mock=args.mock,
+                            temperature=trying_temp,
+                            compress_assign=args.compress_assign,
+                            total_lines=args.compress_assign_total_lines,
+                            prefix_lines=args.compress_assign_prefix_lines,
+                            suffix_lines=args.compress_assign_suffix_lines,
+                        )
+                        found_related_locs[pred_file] = found_related_locs_i[pred_file]
+                        additional_artifact_loc_related.append(
+                            additional_artifact_loc_related_i
+                        )
+                        related_loc_traj.append(related_loc_traj_i)
+                    related_loc_trajs.append(related_loc_traj)
+
+                    if check_contains_valid_loc(
+                        found_related_locs, structure=structure
+                    ):
+                        break
+                    trying_temp = 1.0  # set trying temp to 1 to get valid locs
+                else:
+                    # directly use raw code file instead of skeleton format as ablation
+                    (
+                        found_related_locs,
+                        additional_artifact_loc_related,
+                        related_loc_traj,
+                    ) = fl.localize_function_from_raw_text(
+                        pred_files,
+                        mock=args.mock,
+                        temperature=trying_temp,
+                        keep_old_order=args.keep_old_order,
+                    )
+                    additional_artifact_loc_related = [additional_artifact_loc_related]
+                    related_loc_trajs.append(related_loc_traj)
+
+                    if check_contains_valid_loc(
+                        found_related_locs, structure=structure
+                    ):
+                        break
+
+                    logger.info(
+                        f"No valid related locations found ... retrying with higher temperature ..."
+                    )
+                    trying_temp = 1.0  # set trying temp to 1 to get valid locs
+
+    if args.fine_grain_line_level:
+        if len(found_files) != 0:
+            # Only supports the following args for now
+            trying_temp = args.temperature
+            for _ in range(MAX_RETRIES):
+                pred_files = found_files[: args.top_n]
+                fl = LLMFL(
+                    instance_id,
+                    structure,
+                    problem_statement,
+                    args.model,
+                    args.backend,
+                    logger,
+                )
+                if not args.direct_edit_loc:
+                    coarse_found_locs = found_related_locs
+                    (
+                        found_edit_locs,
+                        additional_artifact_loc_edit_location,
+                        edit_loc_traj,
+                    ) = fl.localize_line_from_coarse_function_locs(
+                        pred_files,
+                        coarse_found_locs,
+                        context_window=args.context_window,
+                        add_space=args.add_space,
+                        no_line_number=args.no_line_number,
+                        sticky_scroll=args.sticky_scroll,
+                        mock=args.mock,
+                        temperature=trying_temp,
+                        num_samples=args.num_samples,
+                        keep_old_order=args.keep_old_order,
+                    )
+                    additional_artifact_loc_edit_location = [
+                        additional_artifact_loc_edit_location
+                    ]
+                    if args.num_samples > 1 and isinstance(found_edit_locs, dict):
+                        logger.info(
+                            "Requested multiple samples but got a single response from "
+                            f"{args.backend}:{args.model}; wrapping for validation."
+                        )
+                        found_edit_locs = [found_edit_locs]
+
+                    sample_valid = False
+                    if args.num_samples > 1:
+                        for found_edit_loc in found_edit_locs:
+                            if check_contains_valid_loc(
+                                found_edit_loc, structure=structure
+                            ):
+                                # at least one set of location contains valid edit locs is okay
+                                sample_valid = True
+                                break
+                    else:
+                        if check_contains_valid_loc(
+                            found_edit_locs, structure=structure
+                        ):
+                            break
+
+                    if sample_valid:
+                        break
+
+                    logger.info(
+                        f"No valid edit locations found ... retrying with higher temperature ..."
+                    )
+                    trying_temp = 1.0  # set trying temp to 1 to get valid locs
+                else:
+                    # directly use the raw source code to get to edit location, used as ablation setting
+                    (
+                        found_edit_locs,
+                        additional_artifact_loc_edit_location,
+                        edit_loc_traj,
+                    ) = fl.localize_line_from_raw_text(
+                        pred_files,
+                        mock=args.mock,
+                        temperature=trying_temp,
+                        num_samples=args.num_samples,
+                        keep_old_order=args.keep_old_order,
+                    )
+                    additional_artifact_loc_edit_location = [
+                        additional_artifact_loc_edit_location
+                    ]
+                    if args.num_samples > 1 and isinstance(found_edit_locs, dict):
+                        logger.info(
+                            "Requested multiple samples but got a single response from "
+                            f"{args.backend}:{args.model}; wrapping for validation."
+                        )
+                        found_edit_locs = [found_edit_locs]
+
+                    if check_contains_valid_loc(
+                        found_related_locs, structure=structure
+                    ):
+                        break
+
+                    sample_valid = False
+                    if args.num_samples > 1:
+                        for found_edit_loc in found_edit_locs:
+                            if check_contains_valid_loc(
+                                found_edit_loc, structure=structure
+                            ):
+                                # at least one set of location contains valid edit locs is okay
+                                sample_valid = True
+                                break
+                    else:
+                        if check_contains_valid_loc(
+                            found_edit_locs, structure=structure
+                        ):
+                            break
+
+                    if sample_valid:
+                        break
+
+                    logger.info(
+                        f"No valid edit locations found ... retrying with higher temperature ..."
+                    )
+                    trying_temp = 1.0  # set trying temp to 1 to get valid locs
+
+    if write_lock is not None:
+        write_lock.acquire()
+    with open(args.output_file, "a") as f:
+        f.write(
+            json.dumps(
+                {
+                    "instance_id": instance_id,
+                    "found_files": found_files,
+                    "additional_artifact_loc_file": additional_artifact_loc_file,
+                    "file_traj": file_traj,
+                    "found_related_locs": found_related_locs,
+                    "additional_artifact_loc_related": additional_artifact_loc_related,
+                    "related_loc_traj": related_loc_trajs,
+                    "found_edit_locs": found_edit_locs,
+                    "additional_artifact_loc_edit_location": additional_artifact_loc_edit_location,
+                    "edit_loc_traj": edit_loc_traj,
+                }
+            )
+            + "\n"
+        )
+    if write_lock is not None:
+        write_lock.release()
+
+
+def localize_irrelevant(args):
+    swe_bench_data = load_bench_data(args)
+    existing_instance_ids = (
+        load_existing_instance_ids(args.output_file) if args.skip_existing else set()
+    )
+    if args.num_threads == 1:
+        for bug in tqdm(swe_bench_data, colour="MAGENTA"):
+            localize_irrelevant_instance(
+                bug, args, swe_bench_data, existing_instance_ids
+            )
+    else:
+        write_lock = Lock()
+        with concurrent.futures.ThreadPoolExecutor(
+            max_workers=args.num_threads
+        ) as executor:
+            futures = [
+                executor.submit(
+                    localize_irrelevant_instance,
+                    bug,
+                    args,
+                    swe_bench_data,
+                    existing_instance_ids,
+                    write_lock,
+                )
+                for bug in swe_bench_data
+            ]
+            for future in tqdm(
+                concurrent.futures.as_completed(futures),
+                total=len(swe_bench_data),
+                colour="MAGENTA",
+            ):
+                future.result()
+
+
+def localize(args):
+    swe_bench_data = load_bench_data(args)
+    start_file_locs = load_jsonl(args.start_file) if args.start_file else None
+    existing_instance_ids = (
+        load_existing_instance_ids(args.output_file) if args.skip_existing else set()
+    )
+
+    if args.num_threads == 1:
+        for bug in tqdm(swe_bench_data, colour="MAGENTA"):
+            localize_instance(
+                bug, args, swe_bench_data, start_file_locs, existing_instance_ids
+            )
+    else:
+        write_lock = Lock()
+        with concurrent.futures.ThreadPoolExecutor(
+            max_workers=args.num_threads
+        ) as executor:
+            futures = [
+                executor.submit(
+                    localize_instance,
+                    bug,
+                    args,
+                    swe_bench_data,
+                    start_file_locs,
+                    existing_instance_ids,
+                    write_lock,
+                )
+                for bug in swe_bench_data
+            ]
+            for future in tqdm(
+                concurrent.futures.as_completed(futures),
+                total=len(swe_bench_data),
+                colour="MAGENTA",
+            ):
+                future.result()
+
+
+def merge(args):
+    """Merge predicted locations."""
+    start_file_locs = load_jsonl(args.start_file)
+
+    def merge_locs(sample_found_locs: list[dict]):
+        merged_found_locs = {}
+        for locs in sample_found_locs:
+            for fn, file_found_locs in locs.items():
+                if isinstance(file_found_locs, str) and file_found_locs.strip():
+                    merged_found_locs.setdefault(fn, [""])[0] += "\n" + file_found_locs
+                elif "\n".join(file_found_locs).strip():
+                    merged_found_locs.setdefault(fn, [""])[0] += "\n" + "\n".join(
+                        file_found_locs
+                    )
+        return merged_found_locs
+
+    # Dump each location sample.
+    for st_id in range(args.num_samples):
+        en_id = st_id
+        merged_locs = []
+        for locs in start_file_locs:
+            merged_found_locs = []
+            if "found_edit_locs" in locs and len(locs["found_edit_locs"]):
+                merged_found_locs = merge_locs(
+                    locs["found_edit_locs"][st_id : st_id + 1]
+                )
+            merged_locs.append({**locs, "found_edit_locs": merged_found_locs})
+        with open(
+            f"{args.output_folder}/loc_merged_{st_id}-{en_id}_outputs.jsonl", "w"
+        ) as f:
+            for data in merged_locs:
+                f.write(json.dumps(data) + "\n")
+
+
+def check_valid_args(args):
+    assert (
+        not os.path.exists(args.output_file) or args.skip_existing
+    ), "Output file already exists and not set to skip existing localizations"
+
+    assert not (
+        args.file_level and args.start_file
+    ), "Cannot use both file_level and start_file"
+
+    assert not (
+        args.file_level and args.fine_grain_line_level and not args.related_level
+    ), "Cannot use both file_level and fine_grain_line_level without related_level"
+
+    assert not (
+        (not args.file_level) and (not args.start_file)
+    ), "Must use either file_level or start_file"
+
+    assert (not "deepseek" in args.model) or (
+        args.backend == "deepseek"
+    ), "Must specify `--backend deepseek` if using a DeepSeek model"
+
+
+def main():
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument("--output_folder", type=str, required=True)
+    parser.add_argument("--output_file", type=str, default="loc_outputs.jsonl")
+    parser.add_argument(
+        "--start_file",
+        type=str,
+        help="""previous output file to start with to reduce
+        the work, should use in combination without --file_level""",
+    )
+    parser.add_argument("--file_level", action="store_true")
+    parser.add_argument("--related_level", action="store_true")
+    parser.add_argument("--fine_grain_line_level", action="store_true")
+    parser.add_argument("--top_n", type=int, default=3)
+    parser.add_argument("--temperature", type=float, default=0.0)
+    parser.add_argument("--num_samples", type=int, default=1)
+    parser.add_argument("--compress", action="store_true")
+    parser.add_argument("--compress_assign", action="store_true")
+    parser.add_argument("--compress_assign_total_lines", type=int, default=30)
+    parser.add_argument("--compress_assign_prefix_lines", type=int, default=10)
+    parser.add_argument("--compress_assign_suffix_lines", type=int, default=10)
+    parser.add_argument("--merge", action="store_true")
+    parser.add_argument("--add_space", action="store_true")
+    parser.add_argument("--no_line_number", action="store_true")
+    parser.add_argument("--sticky_scroll", action="store_true")
+    parser.add_argument("--related_level_separate_file", action="store_true")
+    parser.add_argument("--context_window", type=int, default=10)
+    parser.add_argument("--keep_old_order", action="store_true")
+    parser.add_argument("--irrelevant", action="store_true")
+    parser.add_argument("--direct_edit_loc", action="store_true")
+    parser.add_argument(
+        "--num_threads",
+        type=int,
+        default=1,
+        help="Number of threads to use for creating API requests",
+    )
+    parser.add_argument("--target_id", type=str)
+    parser.add_argument(
+        "--skip_existing",
+        action="store_true",
+        help="Skip localization of instance id's which already contain a localization in the output file.",
+    )
+    parser.add_argument(
+        "--mock", action="store_true", help="Mock run to compute prompt tokens."
+    )
+    parser.add_argument(
+        "--model",
+        type=str,
+        default=os.getenv("AGENTLESS_MODEL", "gpt-5.2"),
+        help="Model name (defaults to $AGENTLESS_MODEL).",
+    )
+    parser.add_argument(
+        "--backend",
+        type=str,
+        default="openai",
+        choices=["openai", "deepseek", "anthropic"],
+    )
+    parser.add_argument(
+        "--dataset",
+        type=str,
+        default="princeton-nlp/SWE-bench_Lite",
+        choices=["princeton-nlp/SWE-bench_Lite", "princeton-nlp/SWE-bench_Verified"],
+        help="Current supported dataset for evaluation",
+    )
+    parser.add_argument(
+        "--dataset_path",
+        type=str,
+        help="Local dataset file (JSON or JSONL) built by build_dataset.py.",
+    )
+    parser.add_argument(
+        "--dataset_split",
+        type=str,
+        default="test",
+        help="Split name when loading an HF dataset.",
+    )
+
+    args = parser.parse_args()
+    args.output_file = os.path.join(args.output_folder, args.output_file)
+    check_valid_args(args)
+
+    os.makedirs(os.path.join(args.output_folder, "localization_logs"), exist_ok=True)
+    os.makedirs(args.output_folder, exist_ok=True)
+
+    # write the arguments
+    with open(f"{args.output_folder}/args.json", "w") as f:
+        json.dump(vars(args), f, indent=4)
+
+    if args.merge:
+        merge(args)
+    elif args.irrelevant:
+        localize_irrelevant(args)
+    else:
+        localize(args)
+
+
+if __name__ == "__main__":
+    main()

Repos/HWE/agents/Agentless/agentless/fl/retrieve.py

@@ -0,0 +1,204 @@
+import argparse
+import concurrent.futures
+import json
+import os
+from threading import Lock
+
+from datasets import load_dataset
+from tqdm import tqdm
+
+from agentless.fl.Index import EmbeddingIndex
+from agentless.util.preprocess_data import (
+    filter_non_source,
+    filter_out_test_files,
+    get_repo_structure,
+)
+from agentless.util.utils import load_json, load_jsonl, setup_logger
+
+
+def load_bench_data(args):
+    if args.dataset_path:
+        if args.dataset_path.endswith(".jsonl"):
+            return load_jsonl(args.dataset_path)
+        if args.dataset_path.endswith(".json"):
+            with open(args.dataset_path, "r") as f:
+                return json.load(f)
+        raise ValueError("Unsupported dataset_path; use .json or .jsonl")
+    return load_dataset(args.dataset, split=args.dataset_split)
+
+
+def retrieve_locs(bug, args, swe_bench_data, found_files, prev_o, write_lock=None):
+
+    found = False
+    for o in prev_o:
+        if o["instance_id"] == bug["instance_id"]:
+            found = True
+            break
+
+    if found:
+        logger.info(f"skipping {bug['instance_id']} since patch already generated")
+        return None
+
+    instance_id = bug["instance_id"]
+
+    if args.target_id is not None:
+        if args.target_id != instance_id:
+            return None
+
+    log_file = os.path.join(args.output_folder, "retrieval_logs", f"{instance_id}.log")
+    logger = setup_logger(log_file)
+    logger.info(f"Processing bug {instance_id}")
+
+    bench_data = [x for x in swe_bench_data if x["instance_id"] == instance_id][0]
+    problem_statement = bench_data["problem_statement"]
+    structure = get_repo_structure(
+        instance_id, bug["repo"], bug["base_commit"], "playground"
+    )
+
+    filter_non_source(structure)
+    filter_out_test_files(structure)
+
+    if args.filter_file:
+        kwargs = {  # build retrieval kwargs
+            "given_files": [x for x in found_files if x["instance_id"] == instance_id][
+                0
+            ]["found_files"],
+            "filter_top_n": args.filter_top_n,
+        }
+    else:
+        kwargs = {}
+
+    # main retrieval
+    retriever = EmbeddingIndex(
+        instance_id,
+        structure,
+        problem_statement,
+        persist_dir=args.persist_dir,
+        filter_type=args.filter_type,
+        index_type=args.index_type,
+        chunk_size=args.chunk_size,
+        chunk_overlap=args.chunk_overlap,
+        logger=logger,
+        **kwargs,
+    )
+
+    file_names, meta_infos, traj = retriever.retrieve(mock=args.mock)
+
+    if write_lock is not None:
+        write_lock.acquire()
+    with open(args.output_file, "a") as f:
+        f.write(
+            json.dumps(
+                {
+                    "instance_id": instance_id,
+                    "found_files": file_names,
+                    "node_info": meta_infos,
+                    "traj": traj,
+                }
+            )
+            + "\n"
+        )
+    if write_lock is not None:
+        write_lock.release()
+
+
+def retrieve(args):
+    if args.filter_file:
+        found_files = load_jsonl(args.filter_file)
+    else:
+        found_files = []
+
+    swe_bench_data = load_bench_data(args)
+    prev_o = load_jsonl(args.output_file) if os.path.exists(args.output_file) else []
+
+    if args.num_threads == 1:
+        for bug in tqdm(swe_bench_data, colour="MAGENTA"):
+            retrieve_locs(
+                bug, args, swe_bench_data, found_files, prev_o, write_lock=None
+            )
+    else:
+        write_lock = Lock()
+        with concurrent.futures.ThreadPoolExecutor(
+            max_workers=args.num_threads
+        ) as executor:
+            futures = [
+                executor.submit(
+                    retrieve_locs,
+                    bug,
+                    args,
+                    swe_bench_data,
+                    found_files,
+                    prev_o,
+                    write_lock,
+                )
+                for bug in swe_bench_data
+            ]
+            for _ in tqdm(
+                concurrent.futures.as_completed(futures),
+                total=len(swe_bench_data),
+                colour="MAGENTA",
+            ):
+                pass
+
+
+def main():
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument("--output_folder", type=str, required=True)
+    parser.add_argument("--output_file", type=str, default="retrieve_locs.jsonl")
+    parser.add_argument(
+        "--index_type", type=str, default="simple", choices=["simple", "complex"]
+    )
+    parser.add_argument(
+        "--filter_type", type=str, default="none", choices=["none", "given_files"]
+    )
+    parser.add_argument("--filter_top_n", type=int, default=None)
+    parser.add_argument("--filter_file", type=str, default="")
+    parser.add_argument("--chunk_size", type=int, default=1024)
+    parser.add_argument("--chunk_overlap", type=int, default=0)
+    parser.add_argument("--persist_dir", type=str)
+    parser.add_argument("--target_id", type=str)
+    parser.add_argument("--mock", action="store_true")
+    parser.add_argument(
+        "--num_threads",
+        type=int,
+        default=1,
+        help="Number of threads to use for creating API requests (WARNING, embedding token counts are only accurate when thread=1)",
+    )
+    parser.add_argument(
+        "--dataset",
+        type=str,
+        default="princeton-nlp/SWE-bench_Lite",
+        choices=["princeton-nlp/SWE-bench_Lite", "princeton-nlp/SWE-bench_Verified"],
+    )
+    parser.add_argument(
+        "--dataset_path",
+        type=str,
+        help="Local dataset file (JSON or JSONL) built by build_dataset.py.",
+    )
+    parser.add_argument(
+        "--dataset_split",
+        type=str,
+        default="test",
+        help="Split name when loading an HF dataset.",
+    )
+
+    args = parser.parse_args()
+
+    args.output_file = os.path.join(args.output_folder, args.output_file)
+    assert (
+        not args.filter_type == "given_files" or args.filter_file != ""
+    ), "Need to provide a filtering file"
+
+    os.makedirs(args.output_folder, exist_ok=True)
+    os.makedirs(os.path.join(args.output_folder, "retrieval_logs"), exist_ok=True)
+
+    # dump argument
+    with open(os.path.join(args.output_folder, "args.json"), "w") as f:
+        json.dump(vars(args), f, indent=4)
+
+    retrieve(args)
+
+
+if __name__ == "__main__":
+    main()

Repos/HWE/agents/Agentless/agentless/repair/repair.py

@@ -0,0 +1,855 @@
+import argparse
+import concurrent.futures
+import json
+import os
+from difflib import unified_diff
+from threading import Lock
+
+from datasets import load_dataset
+from tqdm import tqdm
+
+from agentless.util.api_requests import num_tokens_from_messages
+from agentless.util.model import make_model
+from agentless.util.postprocess_data import (
+    check_code_differ_by_just_empty_lines,
+    check_syntax,
+    extract_python_blocks,
+    fake_git_repo,
+    lint_code,
+    parse_diff_edit_commands,
+    parse_edit_commands,
+    parse_str_replace_edit_commands,
+    split_edit_multifile_commands,
+)
+from agentless.util.preprocess_data import (
+    get_full_file_paths_and_classes_and_functions,
+    get_repo_structure,
+    line_wrap_content,
+    transfer_arb_locs_to_locs,
+)
+from agentless.util.utils import cleanup_logger, load_jsonl, setup_logger
+
+
+def load_bench_data(args):
+    if args.dataset_path:
+        if args.dataset_path.endswith(".jsonl"):
+            return load_jsonl(args.dataset_path)
+        if args.dataset_path.endswith(".json"):
+            with open(args.dataset_path, "r") as f:
+                return json.load(f)
+        raise ValueError("Unsupported dataset_path; use .json or .jsonl")
+    return load_dataset(args.dataset, split=args.dataset_split)
+
+
+repair_relevant_file_instruction = """
+Below are some code segments, each from a relevant file in a Verilog/SystemVerilog hardware design/verification repository. One or more of these files may contain bugs (e.g., RTL logic issues, reset/clocking problems, parameterization mistakes, width mismatches, or testbench/constraint errors).
+"""
+
+repair_prompt_combine_topn = """
+We are currently solving the following issue within our Verilog/SystemVerilog repository. Here is the issue text:
+--- BEGIN ISSUE ---
+{problem_statement}
+--- END ISSUE ---
+
+{repair_relevant_file_instruction}
+--- BEGIN FILE ---
+```systemverilog
+{content}
+--- END FILE ---
+
+Please generate edit_file commands to fix the issue (e.g., adjust RTL modules/interfaces/packages, fix always_comb/always_ff logic, correct signal widths/types, parameters/localparams, assigns, generate blocks, or testbench assertions).
+
+The edit_file command takes four arguments:
+
+edit_file(filename: str, start: int, end: int, content: str) -> None:
+Edit a file. It replaces lines start through end (inclusive) with the given text content in the open file.
+Args:
+filename: str: The full file name to edit.
+start: int: The start line number. Must satisfy start >= 1.
+end: int: The end line number. Must satisfy start <= end <= number of lines in the file.
+content: str: The content to replace the lines with.
+
+Please note that THE edit_file FUNCTION REQUIRES PROPER INDENTATION. If you would like to add the line ' $display(x);', you must fully write that out, with all those spaces before the code!
+Wrap the edit_file command in ```python``` blocks, and include the full file path inside the block as the edit_file filename argument (do not put file paths outside the block).
+"""
+
+repair_prompt_combine_topn_cot = """
+We are currently solving the following issue within our Verilog/SystemVerilog repository. Here is the issue text:
+--- BEGIN ISSUE ---
+{problem_statement}
+--- END ISSUE ---
+
+{repair_relevant_file_instruction}
+--- BEGIN FILE ---
+
+{content}
+--- END FILE ---
+
+Please first localize the bug based on the issue statement (e.g., identify the faulty module/interface/package, signal, parameter, always block, assignment, or assertion), and then generate edit_file commands to fix the issue.
+
+The edit_file command takes four arguments:
+
+edit_file(filename: str, start: int, end: int, content: str) -> None:
+Edit a file. It replaces lines start through end (inclusive) with the given text content in the open file.
+Args:
+filename: str: The full file name to edit.
+start: int: The start line number. Must satisfy start >= 1.
+end: int: The end line number. Must satisfy start <= end <= number of lines in the file.
+content: str: The content to replace the lines with.
+
+Please note that THE edit_file FUNCTION REQUIRES PROPER INDENTATION. If you would like to add the line ' $display(x);', you must fully write that out, with all those spaces before the code!
+Wrap the edit_file command in ```python``` blocks, and include the full file path inside the block as the edit_file filename argument (do not put file paths outside the block).
+"""
+
+repair_prompt_combine_topn_cot_diff = """
+We are currently solving the following issue within our Verilog/SystemVerilog repository. Here is the issue text:
+--- BEGIN ISSUE ---
+{problem_statement}
+--- END ISSUE ---
+
+{repair_relevant_file_instruction}
+--- BEGIN FILE ---
+
+{content}
+--- END FILE ---
+
+Please first localize the bug based on the issue statement (e.g., identify the faulty module/interface/package, signal, parameter, always block, assignment, generate block, or assertion), and then generate SEARCH/REPLACE edits to fix the issue.
+
+Every SEARCH/REPLACE edit must use this format:
+
+The file path
+
+The start of search block: <<<<<<< SEARCH
+
+A contiguous chunk of lines to search for in the existing source code
+
+The dividing line: =======
+
+The lines to replace into the source code
+
+The end of the replace block: >>>>>>> REPLACE
+
+Here is an example:
+
+```python
+### rtl/top.sv
+<<<<<<< SEARCH
+module top(input logic clk, input logic rst_n);
+=======
+module top(input logic clk, input logic rst_n);
+  // Added reset synchronizer
+>>>>>>> REPLACE
+```
+Please note that the SEARCH/REPLACE edit REQUIRES PROPER INDENTATION. If you would like to add the line ' $display(x);', you must fully write that out, with all those spaces before the code!
+Wrap EACH SEARCH/REPLACE edit in a ```python block, and include the file path as the first line INSIDE that block.
+"""
+
+repair_prompt_combine_topn_cot_str_replace = """
+We are currently solving the following issue within our Verilog/SystemVerilog repository. Here is the issue text:
+--- BEGIN ISSUE ---
+{problem_statement}
+--- END ISSUE ---
+
+{repair_relevant_file_instruction}
+--- BEGIN FILE ---
+
+{content}
+--- END FILE ---
+
+Please first localize the bug based on the issue statement, and then generate editing commands to fix the issue (e.g., update RTL modules/interfaces/packages, fix signal widths/types, reset/clock logic, parameters/localparams, combinational/sequential logic, assertions, or testbench drivers).
+Each edit command must include the full file path in its `path` field, and do not put file paths outside the command.
+"""
+
+def _post_process_multifile_repair(
+    raw_output: str,
+    file_contents: dict[str, str],
+    logger,
+    file_loc_intervals: dict[str, list],
+    diff_format=False,
+    str_replace_format=False,
+) -> tuple[list[str], list[str]]:
+    if not str_replace_format:
+        edit_multifile_commands = extract_python_blocks(raw_output)
+    else:
+        edit_multifile_commands = raw_output
+    edited_files = []
+    new_contents = []
+    try:
+        file_to_commands = split_edit_multifile_commands(
+            edit_multifile_commands,
+            diff_format=diff_format,
+            str_replace_format=str_replace_format,
+        )
+    except Exception as e:
+        logger.error(e)
+        return edited_files, new_contents
+
+    logger.info("=== file_to_commands: ===")
+    logger.info(json.dumps(file_to_commands, indent=2))
+
+    for edited_file_key in file_to_commands:
+        edited_file = ""
+        new_content = ""
+        try:
+            logger.info(f"=== edited_file: {edited_file_key} ===")
+            edit_commands = file_to_commands[edited_file_key]
+            logger.info("=== edit_commands: ===")
+            for c in edit_commands:
+                logger.info(c)
+                logger.info("\n" + "-" * 40)
+            edited_file = eval(edited_file_key)  # convert '"file.py"' to 'file.py'
+            content = file_contents[edited_file]
+            if diff_format:
+                new_content = parse_diff_edit_commands(
+                    edit_commands, content, file_loc_intervals[edited_file]
+                )
+            elif str_replace_format:
+                new_content = parse_str_replace_edit_commands(
+                    edit_commands, content, file_loc_intervals[edited_file]
+                )
+            else:
+                new_content = parse_edit_commands(edit_commands, content)
+        except Exception as e:
+            logger.error(e)
+            edited_file = ""
+            new_content = ""
+
+        if edited_file == "" or new_content == "":
+            continue
+        edited_files.append(edited_file)
+        new_contents.append(new_content)
+        diff = list(
+            unified_diff(
+                content.split("\n"),
+                new_content.split("\n"),
+                fromfile=edited_file,
+                tofile=edited_file,
+                lineterm="",
+            )
+        )
+
+        logger.info(f"extracted patch:")
+        logger.info("\n".join(diff))
+        print("\n".join(diff))
+
+    return edited_files, new_contents
+
+
+def construct_topn_file_context(
+    file_to_locs,
+    pred_files,
+    file_contents,
+    structure,
+    context_window: int,
+    loc_interval: bool = True,
+    fine_grain_loc_only: bool = False,
+    add_space: bool = False,
+    sticky_scroll: bool = False,
+    no_line_number: bool = True,
+):
+    """Concatenate provided locations to form a context.
+
+    loc: {"file_name_1": ["loc_str_1"], ...}
+    """
+    file_loc_intervals = dict()
+    topn_content = ""
+
+    for pred_file, locs in file_to_locs.items():
+        content = file_contents[pred_file]
+        line_locs, context_intervals = transfer_arb_locs_to_locs(
+            locs,
+            structure,
+            pred_file,
+            context_window,
+            loc_interval,
+            fine_grain_loc_only,
+            file_content=file_contents[pred_file] if pred_file in file_contents else "",
+        )
+
+        if len(line_locs) > 0:
+            # Note that if no location is predicted, we exclude this file.
+            file_loc_content = line_wrap_content(
+                content,
+                context_intervals,
+                add_space=add_space,
+                no_line_number=no_line_number,
+                sticky_scroll=sticky_scroll,
+            )
+            topn_content += f"### {pred_file}\n{file_loc_content}\n\n\n"
+            file_loc_intervals[pred_file] = context_intervals
+
+    return topn_content, file_loc_intervals
+
+
+def process_loc(loc, args, swe_bench_data, prev_o, write_lock=None):
+    instance_id = loc["instance_id"]
+
+    if args.target_id is not None:
+        if args.target_id != instance_id:
+            return
+
+    log_file = os.path.join(args.output_folder, "repair_logs", f"{instance_id}.log")
+    logger = setup_logger(log_file)
+    found = False
+    for o in prev_o:
+        if o["instance_id"] == instance_id:
+            found = True
+            break
+
+    if found:
+        logger.info(f"skipping {instance_id} since patch already generated")
+        return None
+
+    logger.info(f"================ repairing {instance_id} ================")
+    if len(loc["found_files"]) == 0:
+        if write_lock is not None:
+            write_lock.acquire()
+        with open(args.output_file, "a") as f:
+            f.write(
+                json.dumps(
+                    {
+                        "instance_id": instance_id,
+                        "raw_output": [""],
+                        "try_count": [0],
+                        "all_generations": [[]],
+                        "traj": [],
+                        "prev_content": [[]],
+                        "file_names": [[]],
+                    }
+                )
+                + "\n"
+            )
+        if write_lock is not None:
+            write_lock.release()
+        return
+
+    pred_files = loc["found_files"][: args.top_n]
+    bench_data = [x for x in swe_bench_data if x["instance_id"] == instance_id][0]
+    problem_statement = bench_data["problem_statement"]
+    structure = get_repo_structure(
+        instance_id, bench_data["repo"], bench_data["base_commit"], "playground"
+    )
+    files, _, _ = get_full_file_paths_and_classes_and_functions(structure)
+    raw_outputs, counts, all_generations, traj, prev_contents, file_names = (
+        [],
+        [],
+        [],
+        [],
+        [],
+        [],
+    )
+
+    raw_output = ""
+    topn_content = ""
+    # Construct file contents
+    file_contents = dict()
+    for i, pred_file in enumerate(pred_files):
+        content = None
+        for file_content in files:
+            if file_content[0] == pred_file:
+                content = "\n".join(file_content[1])
+                file_contents[pred_file] = content
+                break
+
+        assert content is not None, f"{pred_file} file not found"
+    # Construct top-n file context
+    file_to_edit_locs = dict()
+
+    if "found_edit_locs" in loc:
+        file_to_edit_locs = loc["found_edit_locs"]
+
+    topn_content, file_loc_intervals = construct_topn_file_context(
+        file_to_edit_locs,
+        pred_files,
+        file_contents,
+        structure,
+        context_window=args.context_window,
+        loc_interval=args.loc_interval,
+        fine_grain_loc_only=args.fine_grain_loc_only,
+        add_space=args.add_space,
+        no_line_number=args.diff_format or args.str_replace_format,
+        sticky_scroll=args.sticky_scroll,
+    )
+
+    if topn_content.strip() == "":
+        if write_lock is not None:
+            write_lock.acquire()
+        with open(args.output_file, "a") as f:
+            f.write(
+                json.dumps(
+                    {
+                        "instance_id": instance_id,
+                        "raw_output": [""],
+                        "try_count": [0],
+                        "all_generations": [[]],
+                        "traj": [],
+                        "prev_content": [[]],
+                        "file_names": [[]],
+                    }
+                )
+                + "\n"
+            )
+        if write_lock is not None:
+            write_lock.release()
+        return
+
+    prompt_template = (
+        repair_prompt_combine_topn_cot_str_replace
+        if args.cot and args.str_replace_format
+        else repair_prompt_combine_topn_cot_diff
+        if args.cot and args.diff_format
+        else repair_prompt_combine_topn_cot
+        if args.cot
+        else repair_prompt_combine_topn
+    )
+    file_instruction = repair_relevant_file_instruction
+    message = prompt_template.format(
+        repair_relevant_file_instruction=file_instruction,
+        problem_statement=problem_statement,
+        content=topn_content.rstrip(),
+    ).strip()
+    logger.info(f"prompting with message:\n{message}")
+
+    all_generations, counts, traj, prev_contents, file_names = [], [], [], [], []
+    sample_responses = []
+    # get greedy sample
+    model = make_model(
+        model=args.model,
+        logger=logger,
+        backend=args.backend,
+        max_tokens=1024,
+        temperature=0,
+        batch_size=1,
+    )
+    if args.skip_greedy:
+        greedy_traj = {
+            "response": "",
+            "usage": {
+                "completion_tokens": 0,
+                "prompt_tokens": 0,
+            },
+        }
+    else:
+        if args.mock:
+            greedy_traj = {
+                "response": "",
+                "usage": {
+                    "prompt_tokens": num_tokens_from_messages(message, args.model),
+                },
+            }
+        else:
+            if args.str_replace_format:
+                greedy_traj = model.codegen_w_tool(
+                    message, num_samples=1, prompt_cache=args.max_samples > 1
+                )[0]
+            else:
+                greedy_traj = model.codegen(
+                    message, num_samples=1, prompt_cache=args.max_samples > 1
+                )[0]
+
+    sample_responses.append(greedy_traj)
+    # get temperature samples
+    model = make_model(
+        model=args.model,
+        logger=logger,
+        backend=args.backend,
+        max_tokens=1024,
+        temperature=0.8,
+        batch_size=args.max_samples - 1,  # minus the 1 greedy sample
+    )
+
+    if args.mock:
+        first_traj = {
+            "response": "",
+            "usage": {
+                "prompt_tokens": num_tokens_from_messages(message, args.model),
+            },
+        }
+        later_traj = {
+            "response": "",
+            "usage": {"prompt_tokens": 0},
+        }
+        if args.max_samples - 1:
+            sample_trajs = [first_traj] + [later_traj] * (args.max_samples - 2)
+        else:
+            sample_trajs = []
+    else:
+        if args.max_samples - 1:
+            # always use cached prompt if possible for later samples
+            if args.str_replace_format:
+                sample_trajs = model.codegen_w_tool(
+                    message, num_samples=args.max_samples - 1, prompt_cache=True
+                )
+            else:
+                sample_trajs = model.codegen(
+                    message, num_samples=args.max_samples - 1, prompt_cache=True
+                )
+        else:
+            sample_trajs = []
+
+    sample_responses.extend(sample_trajs)
+
+    count = 0
+    while count < args.max_samples:
+        print(f"trying the {count + 1}-th sample ...")
+        ret = sample_responses[count]
+        count += 1
+        traj.append({**ret, "prompt": message})
+
+        if args.mock:
+            continue
+
+        raw_output = ret["response"]
+        logger.info(f"raw output:\n{raw_output}")
+        all_generations.append(raw_output)
+        edited_files, new_contents = _post_process_multifile_repair(
+            raw_output,
+            file_contents,
+            logger,
+            file_loc_intervals,
+            diff_format=args.diff_format,
+            str_replace_format=args.str_replace_format,
+        )
+
+        if len(new_contents) == 0:
+            prev_contents.append("")
+            file_names.append("")
+        else:
+            prev_content = [file_contents[edited_file] for edited_file in edited_files]
+            prev_contents.append(prev_content)
+            file_names.append(edited_files)
+
+        counts.append(count)
+        raw_outputs.append(raw_output)
+
+    if write_lock is not None:
+        write_lock.acquire()
+    with open(args.output_file, "a") as f:
+        f.write(
+            json.dumps(
+                {
+                    "instance_id": instance_id,
+                    "raw_output": raw_outputs,
+                    "all_generations": [all_generations],
+                    "try_count": counts,
+                    "traj": traj,
+                    "prev_content": [prev_contents],
+                    "file_names": [file_names],
+                }
+            )
+            + "\n"
+        )
+    if write_lock is not None:
+        write_lock.release()
+
+
+def repair(args):
+    with open(f"{args.output_folder}/args.json", "w") as f:
+        json.dump(vars(args), f, indent=4)
+
+    swe_bench_data = load_bench_data(args)
+    locs = load_jsonl(args.loc_file)
+    prev_o = load_jsonl(args.output_file) if os.path.exists(args.output_file) else []
+
+    with open(f"{args.output_folder}/used_locs.jsonl", "w") as f:
+        for loc in locs:
+            f.write(json.dumps(loc) + "\n")
+
+    if args.num_threads == 1:
+        for loc in tqdm(locs, total=len(locs), colour="MAGENTA"):
+            process_loc(loc, args, swe_bench_data, prev_o)
+    else:
+        write_lock = Lock()
+        with concurrent.futures.ThreadPoolExecutor(
+            max_workers=args.num_threads
+        ) as executor:
+            futures = {
+                executor.submit(
+                    process_loc, loc, args, swe_bench_data, prev_o, write_lock
+                ): loc
+                for loc in locs
+            }
+            for future in tqdm(
+                concurrent.futures.as_completed(futures),
+                total=len(locs),
+                colour="MAGENTA",
+            ):
+                future.result()
+
+
+def post_process_raw_output(
+    raw_output_text, file_contents, logger, file_loc_intervals, args
+):
+    git_diffs = ""
+    raw_git_diffs = ""
+    edited_files, new_contents, contents = [], [], []
+    try:
+        edited_files, new_contents = _post_process_multifile_repair(
+            raw_output_text,
+            file_contents,
+            logger,
+            file_loc_intervals,
+            diff_format=args.diff_format,
+            str_replace_format=args.str_replace_format,
+        )
+
+        contents = [file_contents[edited_file] for edited_file in edited_files]
+
+        git_diff = fake_git_repo("playground", edited_files, contents, new_contents)
+
+        raw_git_diffs += "\n" + git_diff.replace("\n", "")
+
+        syntax_success = check_syntax(new_contents)
+
+        differ_by_empty_lines = check_code_differ_by_just_empty_lines(
+            new_contents, contents
+        )
+
+        logger.info(f"{differ_by_empty_lines = }")
+        if syntax_success and not differ_by_empty_lines:
+            git_diffs = raw_git_diffs
+        else:
+            git_diffs = ""  # no need to evaluate
+    except Exception as e:
+        print(raw_output_text)
+        print(e)
+
+    return git_diffs, raw_git_diffs, contents, edited_files, new_contents
+
+
+def post_process_repair(args):
+    """
+    apply some diff formatting.
+    """
+    raw_outputs = load_jsonl(args.raw_output_file)
+    locs = load_jsonl(args.loc_file)
+
+    for raw_output in raw_outputs:
+        instance_id = raw_output["instance_id"]
+        log_file = os.path.join(args.output_folder, "repair_logs", f"{instance_id}.log")
+        logger = setup_logger(log_file)
+
+        if raw_output["raw_output"] == "":
+            with open(args.output_file, "a") as f:
+                f.write(
+                    json.dumps(
+                        {
+                            "model_name_or_path": "agentless",
+                            "instance_id": instance_id,
+                            "model_patch": "",
+                        }
+                    )
+                    + "\n"
+                )
+            continue
+
+        if args.select_id == -1:
+            # Use the last generation
+            assert False, "not implemented for now"
+        else:
+            # Use the indexed generation
+            generation_idx = args.select_id
+            try:
+                raw_output_text = raw_output["all_generations"][0][generation_idx]
+                original_file_content = raw_output["prev_content"][0][generation_idx]
+                pred_file = raw_output["file_names"][0][generation_idx]
+
+                pred_files = [loc for loc in locs if loc["instance_id"] == instance_id][
+                    0
+                ]["found_files"][: args.top_n]
+
+                git_diffs = ""
+                raw_git_diffs = ""
+                if isinstance(raw_output["raw_output"], str):
+                    # for backward compatibility
+                    raw_output["raw_output"] = [raw_output["raw_output"]]
+
+                if isinstance(original_file_content, str):
+                    original_file_content = [original_file_content]
+                    pred_file = [pred_file]
+
+                file_contents = {
+                    file_name: o_file_content
+                    for file_name, o_file_content in zip(
+                        pred_file, original_file_content
+                    )
+                }
+
+                file_loc_intervals = dict()
+
+                loc = [loc for loc in locs if loc["instance_id"] == instance_id][0]
+
+                for i, tmp_pred_file in enumerate(pred_files):
+                    if tmp_pred_file not in pred_file:
+                        continue
+                    if (
+                        "found_edit_locs" in loc
+                        and tmp_pred_file in loc["found_edit_locs"]
+                    ):
+                        line_locs, context_intervals = transfer_arb_locs_to_locs(
+                            loc["found_edit_locs"][tmp_pred_file],
+                            None,
+                            loc["found_files"][i],
+                            args.context_window,
+                            args.loc_interval,
+                            args.fine_grain_loc_only,
+                            file_content=file_contents[tmp_pred_file]
+                            if tmp_pred_file in file_contents
+                            else "",
+                        )
+                    else:
+                        line_locs, context_intervals = [], []  # default values.
+
+                    file_loc_intervals[tmp_pred_file] = context_intervals
+            except Exception as e:
+                logger.info(e)
+                print(e)
+                raw_output_text = ""
+
+        if raw_output_text:
+            (
+                git_diffs,
+                raw_git_diffs,
+                content,
+                edited_files,
+                new_contents,
+            ) = post_process_raw_output(
+                raw_output_text, file_contents, logger, file_loc_intervals, args
+            )
+        else:
+            git_diffs = ""
+            raw_git_diffs = ""
+            content = []
+            edited_files = []
+            new_contents = []
+
+        with open(args.output_file, "a") as f:
+            f.write(
+                json.dumps(
+                    {
+                        "model_name_or_path": "agentless",
+                        "instance_id": instance_id,
+                        "model_patch": git_diffs.lstrip(),
+                        "raw_model_patch": raw_git_diffs.lstrip(),
+                        "original_file_content": content,
+                        "edited_files": edited_files,
+                        "new_file_content": new_contents,
+                    }
+                )
+                + "\n"
+            )
+        cleanup_logger(logger)
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--loc_file", type=str, required=True)
+    parser.add_argument("--top_n", type=int, default=1)
+    parser.add_argument("--loc_interval", action="store_true")
+    parser.add_argument("--context_window", type=int, default=10)
+    parser.add_argument("--gen_and_process", action="store_true")
+    parser.add_argument("--max_samples", type=int, default=20, help="Sampling budget.")
+    parser.add_argument(
+        "--select_id",
+        type=int,
+        default=-1,
+        help="Index the selected samples during post-processing.",
+    )
+    parser.add_argument(
+        "--model",
+        type=str,
+        default=os.getenv("AGENTLESS_MODEL", "gpt-5.2"),
+        help="Model name (defaults to $AGENTLESS_MODEL).",
+    )
+    parser.add_argument(
+        "--backend",
+        type=str,
+        default="openai",
+        choices=["openai", "deepseek", "anthropic"],
+    )
+    parser.add_argument("--output_folder", type=str, required=True)
+    parser.add_argument("--post_process", action="store_true")
+    parser.add_argument("--add_space", action="store_true")
+    parser.add_argument("--cot", action="store_true")
+    parser.add_argument("--fine_grain_loc_only", action="store_true")
+    parser.add_argument("--diff_format", action="store_true")
+    parser.add_argument("--str_replace_format", action="store_true")
+    parser.add_argument("--skip_greedy", action="store_true")
+    parser.add_argument("--sticky_scroll", action="store_true")
+    parser.add_argument(
+        "--num_threads",
+        type=int,
+        default=1,
+        help="Number of threads to use for creating API requests",
+    )
+    parser.add_argument("--target_id", type=str)
+    parser.add_argument(
+        "--mock", action="store_true", help="Mock run to compute prompt tokens."
+    )
+    parser.add_argument(
+        "--dataset",
+        type=str,
+        default="princeton-nlp/SWE-bench_Lite",
+        choices=["princeton-nlp/SWE-bench_Lite", "princeton-nlp/SWE-bench_Verified"],
+    )
+    parser.add_argument(
+        "--dataset_path",
+        type=str,
+        help="Local dataset file (JSON or JSONL) built by build_dataset.py.",
+    )
+    parser.add_argument(
+        "--dataset_split",
+        type=str,
+        default="test",
+        help="Split name when loading an HF dataset.",
+    )
+
+    args = parser.parse_args()
+
+    assert (not "deepseek" in args.model) or (
+        args.backend == "deepseek"
+    ), "Must specify `--backend deepseek` if using a DeepSeek model"
+
+    # diff_format and str_replace_format cannot be both True
+    assert not (
+        args.diff_format and args.str_replace_format
+    ), "Cannot use both diff_format and str_replace_format"
+
+    # str_replace_format only supported with anthropic backend
+    assert not (
+        args.str_replace_format and args.backend != "anthropic"
+    ), "str_replace_format only supported with anthropic backend"
+
+    if not os.path.exists(args.output_folder):
+        os.makedirs(args.output_folder)
+    if not os.path.exists(os.path.join(args.output_folder, "repair_logs")):
+        os.makedirs(os.path.join(args.output_folder, "repair_logs"))
+
+    args.output_file = os.path.join(args.output_folder, "output.jsonl")
+
+    if args.post_process:
+        args.raw_output_file = args.output_file
+        if args.select_id == -1:
+            args.output_file = args.raw_output_file.replace(
+                ".jsonl", "_processed.jsonl"
+            )
+        else:
+            args.output_file = args.raw_output_file.replace(
+                ".jsonl", f"_{args.select_id}_processed.jsonl"
+            )
+        post_process_repair(args)
+    elif args.gen_and_process:
+        repair(args)
+        args.raw_output_file = args.output_file
+        for i in range(args.max_samples):
+            args.output_file = args.raw_output_file.replace(
+                ".jsonl", f"_{i}_processed.jsonl"
+            )
+            args.select_id = i
+            post_process_repair(args)
+    else:
+        repair(args)
+
+
+if __name__ == "__main__":
+    main()

Repos/HWE/agents/Agentless/agentless/repair/rerank.py

@@ -0,0 +1,343 @@
+import argparse
+import json
+import os
+from collections import Counter
+from pathlib import Path
+
+from agentless.util.postprocess_data import normalize_patch
+from agentless.util.utils import load_json, load_jsonl
+
+execution_results = dict()
+
+
+def _load_results(args):
+    global execution_results
+
+    roots = [Path(folder) for folder in args.patch_folder.split(",")]
+
+    intervals = [(0, int(args.num_samples / len(roots)) - 1) for _ in range(len(roots))]
+
+    interval = intervals[0]
+    for i in range(interval[0], interval[1] + 1):
+        for _, root in enumerate(roots):
+            patches = load_jsonl(root / f"output_{i}_normalized.jsonl")
+            print(
+                f"Loaded {len(patches)} patches from {root / f'output_{i}_normalized.jsonl'}"
+            )
+            if args.regression:
+                regression_test_results = load_jsonl(
+                    root / f"output_{i}_regression_test_results.jsonl"
+                )
+            if args.reproduction:
+                reproduction_test_results = load_jsonl(
+                    root / f"output_{i}_reproduction_test_results.jsonl"
+                )
+
+            for patch in patches[:]:
+                if args.regression:
+                    regression_test_result = [
+                        x
+                        for x in regression_test_results
+                        if x["instance_id"] == patch["instance_id"]
+                    ][0].get("regression", [0] * 10000)
+                    regression_test_result = len(regression_test_result)
+                else:
+                    regression_test_result = 0
+
+                if args.reproduction:
+                    if (
+                        len(
+                            [
+                                x
+                                for x in reproduction_test_results
+                                if x["instance_id"] == patch["instance_id"]
+                            ]
+                        )
+                        == 1
+                    ):
+                        reproduction_test_result = [
+                            x
+                            for x in reproduction_test_results
+                            if x["instance_id"] == patch["instance_id"]
+                        ][0].get("reproduction", False)
+                    else:
+                        reproduction_test_result = False
+                else:
+                    reproduction_test_result = True
+
+                execution_results.setdefault(patch["instance_id"], []).append(
+                    {
+                        "normalized_patch": patch["normalized_patch"].strip(),
+                        "patch": patch["model_patch"],
+                        "regression_test_result": regression_test_result,
+                        "reproduction_test_result": reproduction_test_result,
+                    }
+                )
+
+
+def get_sample(instance_id, sample_id) -> tuple[str, bool]:
+    """Returns the diff and pass status."""
+    return execution_results[instance_id][sample_id]
+
+
+def get_all_patches(instance_id, num_samples, deduplicate) -> list[str]:
+    """Returns all unique patches."""
+    patches = [execution_results[instance_id][i]["patch"] for i in range(num_samples)]
+    if deduplicate:
+        patch_keys = [
+            execution_results[instance_id][i]["normalized_patch"]
+            for i in range(num_samples)
+        ]
+    else:
+        patch_keys = [
+            execution_results[instance_id][i]["patch"] for i in range(num_samples)
+        ]
+    unique_patches = set()
+    patch_ids = []
+    for i in range(num_samples):
+        patch_key = patch_keys[i].strip()
+        if patch_key and patch_key not in unique_patches:
+            unique_patches.add(patch_key)
+            patch_ids.append(i)
+    return [(id, patches[id]) for id in patch_ids]
+
+
+def get_all_patches_num(instance_id, num_samples, deduplicate) -> list[str]:
+    """Returns all unique patches with number."""
+    # print(f"{len(execution_results)}")
+    patches = [execution_results[instance_id][i]["patch"] for i in range(num_samples)]
+    if deduplicate:
+        patch_keys = [
+            execution_results[instance_id][i]["normalized_patch"]
+            for i in range(num_samples)
+        ]
+    else:
+        patch_keys = [
+            execution_results[instance_id][i]["patch"] for i in range(num_samples)
+        ]
+    unique_patches = {}
+    total_patch_num = {}
+    patch_ids = []
+    for i in range(num_samples):
+        if patch_keys[i] and patch_keys[i] not in unique_patches:
+            unique_patches[patch_keys[i]] = i
+            patch_ids.append(i)
+            total_patch_num[i] = 0
+        if patch_keys[i]:
+            total_patch_num[unique_patches[patch_keys[i]]] += 1
+
+    return [(id, patches[id], total_patch_num[id]) for id in patch_ids]
+
+
+class SetEncoder(json.JSONEncoder):
+    def default(self, obj):
+        if isinstance(obj, set):
+            return list(obj)
+        return json.JSONEncoder.default(self, obj)
+
+
+def modified_length(normalized_patch):
+    changed_length = 0
+
+    for line in normalized_patch.splitlines():
+        if len(line) > 3 and (line.startswith("---") or line.startswith("+++")):
+            continue
+
+        if line.startswith("-"):
+            changed_length += 1
+        if line.startswith("+"):
+            changed_length += 1
+
+    assert changed_length != 0
+
+    return changed_length
+
+
+def majority_voting(args):
+
+    with open(args.output_file, "w") as f:
+
+        for instance_id in execution_results:
+            if len(execution_results[instance_id]) < args.num_samples:
+                print(
+                    f"There were only {len(execution_results[instance_id])} patches for {instance_id} instead of the full {args.num_samples}"
+                )
+
+            patch_keys = [
+                execution_results[instance_id][i]["normalized_patch"]
+                for i in range(len(execution_results[instance_id]))
+            ]
+            regression_tests = [
+                execution_results[instance_id][i]["regression_test_result"]
+                for i in range(len(execution_results[instance_id]))
+            ]
+
+            min_tests = min(regression_tests)
+            regression_tests = [
+                True if x == min_tests else False for x in regression_tests
+            ]
+
+            reproduction_tests = [
+                execution_results[instance_id][i]["reproduction_test_result"]
+                for i in range(len(execution_results[instance_id]))
+            ]
+            raw_patches = [
+                execution_results[instance_id][i]["patch"]
+                for i in range(len(execution_results[instance_id]))
+            ]
+
+            if args.regression and not args.reproduction:
+                patch_ids = [
+                    i
+                    for i in range(len(execution_results[instance_id]))
+                    if patch_keys[i].strip() and regression_tests[i]
+                ]
+            elif args.reproduction:
+                patch_ids = [
+                    i
+                    for i in range(len(execution_results[instance_id]))
+                    if patch_keys[i].strip()
+                    and regression_tests[i]
+                    and reproduction_tests[i]
+                ]
+                if len(patch_ids) == 0:
+                    # reset to just using the all regression passing patches
+                    patch_ids = [
+                        i
+                        for i in range(len(execution_results[instance_id]))
+                        if patch_keys[i].strip() and regression_tests[i]
+                    ]
+            else:
+                patch_ids = [
+                    i
+                    for i in range(len(execution_results[instance_id]))
+                    if patch_keys[i].strip()
+                ]
+
+            if not patch_ids:
+                # just vote on all patches
+                if not all([x.strip() == "" for x in raw_patches]) and not all(
+                    [x.strip() == "" for x in patch_keys]
+                ):
+                    vote = Counter()
+                    first_appear_idx = dict()
+                    valid_indices = []
+                    for i in range(len(execution_results[instance_id])):
+                        sample = get_sample(instance_id, i)
+                        patch_key = sample["normalized_patch"]
+                        if patch_key != "":
+                            valid_indices.append(i)
+                            vote[patch_key] += 1
+                            if patch_key not in first_appear_idx:
+                                first_appear_idx[patch_key] = i
+                    maj_selected_id = max(
+                        valid_indices,
+                        key=lambda i: (
+                            vote[patch_keys[i]],
+                            -first_appear_idx[patch_keys[i]],
+                        ),
+                    )
+                    patch = get_sample(instance_id, maj_selected_id)["patch"]
+                    result = {
+                        "model_name_or_path": "agentless",
+                        "instance_id": instance_id,
+                        "model_patch": patch,
+                    }
+                else:
+                    print(f"No raw patches valid for {instance_id}")
+                    result = {
+                        "model_name_or_path": "agentless",
+                        "instance_id": instance_id,
+                        "model_patch": "",
+                    }
+                f.write(json.dumps(result) + "\n")
+                continue
+
+            vote = Counter()
+            first_appear_idx = dict()
+            changed_length_idx = dict()
+            for i in patch_ids:
+                sample = get_sample(instance_id, i)
+                patch_key, patch = sample["normalized_patch"], sample["patch"]
+                vote[patch_key] += 1
+                if patch_key not in first_appear_idx:
+                    first_appear_idx[patch_key] = i
+                    changed_length_idx[patch_key] = modified_length(patch_key)
+
+            maj_selected_id = max(
+                patch_ids,
+                key=lambda i: (vote[patch_keys[i]], -first_appear_idx[patch_keys[i]]),
+            )
+
+            if args.target is not None and instance_id == args.target:
+                for patch in vote:
+                    print(
+                        "=" * 20,
+                        vote[patch],
+                        "=" * 20,
+                    )
+                    print(patch)
+                    print("=" * 50)
+
+            sample = get_sample(instance_id, maj_selected_id)
+            result = {
+                "model_name_or_path": "agentless",
+                "instance_id": instance_id,
+                "model_patch": sample["patch"],
+            }
+
+            f.write(json.dumps(result) + "\n")
+
+
+def normalize_patches(args):
+    # separate the patch folders
+    output_folders = [Path(folder) for folder in args.patch_folder.split(",")]
+    num_folders = len(output_folders)
+    selected_ids = list(range(int(args.num_samples / num_folders)))
+
+    for output_folder in output_folders:
+        for i in selected_ids:
+            if os.path.exists(output_folder / f"output_{i}_normalized.jsonl"):
+                # skip
+                continue
+            patches = load_jsonl(output_folder / f"output_{i}_processed.jsonl")
+            for d in patches:
+                instance_id = d["instance_id"]
+                patch = d["model_patch"]
+                original_file_content = d["original_file_content"]
+                new_file_content = d["new_file_content"]
+                edited_files = d["edited_files"]
+                normalized_patch = normalize_patch(
+                    instance_id,
+                    patch,
+                    original_file_content,
+                    new_file_content,
+                    edited_files,
+                )
+                d["normalized_patch"] = normalized_patch
+            with open(output_folder / f"output_{i}_normalized.jsonl", "w") as f:
+                for d in patches:
+                    f.write(json.dumps(d) + "\n")
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--patch_folder", type=str)
+    parser.add_argument("--target", type=str, default=None)
+    parser.add_argument("--num_samples", type=int, default=11)
+    parser.add_argument("--deduplicate", action="store_true")
+    parser.add_argument("--regression", action="store_true")
+    parser.add_argument("--reproduction", action="store_true")
+    parser.add_argument("--output_file", type=str, default="all_preds.jsonl")
+    args = parser.parse_args()
+
+    # first normalize
+    normalize_patches(args)
+    # then load results
+    _load_results(args)
+    # then rerank
+    majority_voting(args)
+
+
+if __name__ == "__main__":
+    main()

Repos/HWE/agents/Agentless/agentless/test/generate_reproduction_tests.py

@@ -0,0 +1,554 @@
+import argparse
+import ast
+import concurrent.futures
+import json
+import os
+import re
+from collections import Counter
+from threading import Lock
+
+from datasets import load_dataset
+from tqdm import tqdm
+
+from agentless.util.api_requests import num_tokens_from_messages
+from agentless.util.model import make_model
+from agentless.util.postprocess_data import remove_comments_and_docstrings
+from agentless.util.utils import load_jsonl, setup_logger
+
+generate_tests_prompt_template = """
+We are currently solving the following issue within our repository. Here is the issue text:
+--- BEGIN ISSUE ---
+{problem_statement}
+--- END ISSUE ---
+
+Please generate a complete test that can be used to reproduce the issue.
+
+The complete test should contain the following:
+1. Necessary imports
+2. Code to reproduce the issue described in the issue text
+3. Print "Issue reproduced" if the outcome indicates that the issue is reproduced
+4. Print "Issue resolved" if the outcome indicates that the issue has been successfully resolved
+5. Print "Other issues" if the outcome indicates there are other issues with the source code
+
+Here is an example:
+
+```python
+from sqlfluff import lint
+
+def test__rules__std_L060_raised() -> None:
+    try:
+        sql = "SELECT   IFNULL(NULL, 100),
+            NVL(NULL,100);"
+        result = lint(sql, rules=["L060"])
+        assert len(result) == 2
+    except:
+        print("Other issues")
+        return
+
+    try:
+        assert result[0]["description"] == "Use 'COALESCE' instead of 'IFNULL'."
+        assert result[1]["description"] == "Use 'COALESCE' instead of 'NVL'."
+        print("Issue resolved")
+    except AssertionError:
+        print("Issue reproduced")
+        return
+
+    return
+
+test__rules__std_L060_raised()
+```
+
+Please ensure the generated test reflects the issue described in the provided issue text.
+The generated test should be able to be used to both reproduce the issue as well as to verify the issue has been fixed.
+Wrap the complete test in ```python...```.
+"""
+
+
+def create_patch_from_code(python_code: str) -> str:
+    patch_header = """diff --git a/reproduce_bug.py b/reproduce_bug.py
+new file mode 100644
+index 0000000..e69de29
+"""
+    patch_body = []
+    patch_body.append("--- /dev/null")
+    patch_body.append("+++ b/reproduce_bug.py")
+
+    code_lines = python_code.split("\n")
+    patch_body.append(f"@@ -0,0 +1,{len(code_lines)} @@")
+
+    for line in code_lines:
+        patch_body.append(f"+{line}")
+
+    return patch_header + "\n".join(patch_body) + "\n"
+
+
+def extract_first_code_block(text):
+    pattern = re.compile(r"```python(.*?)```", re.DOTALL)
+
+    match = pattern.search(text)
+
+    if match:
+        return match.group(1).strip()
+
+    return None
+
+
+def gen_test(instance_id, args, swe_bench_data, prev_o, write_lock=None):
+
+    if args.target_id is not None:
+        if args.target_id != instance_id:
+            return
+
+    log_file = os.path.join(
+        args.output_folder, "generating_test_logs", f"{instance_id}.log"
+    )
+    logger = setup_logger(log_file)
+    found = False
+    for o in prev_o:
+        if o["instance_id"] == instance_id:
+            found = True
+            break
+
+    if found:
+        logger.info(f"skipping {instance_id} since patch already generated")
+        return None
+
+    logger.info(f"================ generating test for {instance_id} ================")
+
+    bench_data = [x for x in swe_bench_data if x["instance_id"] == instance_id][0]
+    problem_statement = bench_data["problem_statement"]
+
+    raw_outputs, counts, all_generations, traj = (
+        [],
+        [],
+        [],
+        [],
+    )
+
+    raw_output = ""
+
+    prompt_template = generate_tests_prompt_template
+    message = prompt_template.format(
+        problem_statement=problem_statement,
+    ).strip()
+
+    logger.info(f"prompting with message:\n{message}")
+
+    all_generations, counts, traj = [], [], []
+    sample_responses = []
+
+    # get greedy sample
+    model = make_model(
+        model=args.model,
+        logger=logger,
+        backend=args.backend,
+        max_tokens=1024,
+        temperature=0,
+        batch_size=1,
+    )
+    if args.skip_greedy:
+        greedy_traj = {
+            "response": "",
+            "usage": {
+                "completion_tokens": 0,
+                "prompt_tokens": 0,
+            },
+        }
+    else:
+        if args.mock:
+            greedy_traj = {
+                "response": "",
+                "usage": {
+                    "prompt_tokens": num_tokens_from_messages(message, args.model),
+                },
+            }
+        else:
+            greedy_traj = model.codegen(
+                message, num_samples=1, prompt_cache=args.max_samples > 1
+            )[0]
+
+    sample_responses.append(greedy_traj)
+    # get temperature samples
+    model = make_model(
+        model=args.model,
+        logger=logger,
+        backend=args.backend,
+        max_tokens=1024,
+        temperature=0.8,
+        batch_size=args.max_samples - 1,  # minus the 1 greedy sample
+    )
+
+    if args.mock:
+        first_traj = {
+            "response": "",
+            "usage": {
+                "prompt_tokens": num_tokens_from_messages(message, args.model),
+            },
+        }
+        later_traj = {
+            "response": "",
+            "usage": {"prompt_tokens": 0},
+        }
+        if args.max_samples - 1:
+            sample_trajs = [first_traj] + [later_traj] * (args.max_samples - 2)
+        else:
+            sample_trajs = []
+    else:
+        if args.max_samples - 1:
+            # always use cached prompt if possible for later samples
+            sample_trajs = model.codegen(
+                message, num_samples=args.max_samples - 1, prompt_cache=True
+            )
+        else:
+            sample_trajs = []
+
+    sample_responses.extend(sample_trajs)
+
+    count = 0
+    while count < args.max_samples:
+        print(f"trying the {count + 1}-th sample ...")
+        ret = sample_responses[count]
+        count += 1
+        traj.append({**ret, "prompt": message})
+
+        if args.mock:
+            continue
+
+        raw_output = ret["response"]
+        logger.info(f"raw output:\n{raw_output}")
+        print((f"raw output:\n{raw_output}"))
+        all_generations.append(raw_output)
+
+        counts.append(count)
+        raw_outputs.append(raw_output)
+
+    if write_lock is not None:
+        write_lock.acquire()
+    with open(args.output_file, "a") as f:
+        f.write(
+            json.dumps(
+                {
+                    "instance_id": instance_id,
+                    "raw_output": raw_outputs,
+                    "all_generations": [all_generations],
+                    "try_count": counts,
+                    "traj": traj,
+                    "prev_content": [
+                        [""]
+                    ],  # To make the tests compatible with the repair setup
+                    "file_names": [["reproduce_bug.py"]],
+                }
+            )
+            + "\n"
+        )
+    if write_lock is not None:
+        write_lock.release()
+
+
+def generate_tests(args):
+    with open(f"{args.output_folder}/args.json", "w") as f:
+        json.dump(vars(args), f, indent=4)
+
+    swe_bench_data = load_dataset(args.dataset, split="test")
+    instances = swe_bench_data["instance_id"]
+    prev_o = load_jsonl(args.output_file) if os.path.exists(args.output_file) else []
+
+    if args.num_threads == 1:
+        for instance_id in tqdm(instances, total=len(instances), colour="MAGENTA"):
+            gen_test(instance_id, args, swe_bench_data, prev_o)
+    else:
+        write_lock = Lock()
+        with concurrent.futures.ThreadPoolExecutor(
+            max_workers=args.num_threads
+        ) as executor:
+            futures = {
+                executor.submit(
+                    gen_test, instance_id, args, swe_bench_data, prev_o, write_lock
+                ): instance_id
+                for instance_id in instances
+            }
+            for future in tqdm(
+                concurrent.futures.as_completed(futures),
+                total=len(instances),
+                colour="MAGENTA",
+            ):
+                future.result()
+
+
+def post_process_tests(args):
+    """
+    apply some diff formatting.
+    """
+    raw_outputs = load_jsonl(args.raw_output_file)
+    generation_idx = args.select_id
+
+    for raw_output in raw_outputs:
+        instance_id = raw_output["instance_id"]
+
+        if (
+            raw_output["raw_output"] == ""
+            or not raw_output["all_generations"][0][generation_idx]
+        ):
+            with open(args.output_file, "a") as f:
+                f.write(
+                    json.dumps(
+                        {
+                            "model_name_or_path": "agentless",
+                            "instance_id": instance_id,
+                            "test_patch": "",
+                        }
+                    )
+                    + "\n"
+                )
+            continue
+
+        if args.select_id == -1:
+            # Use the last generation
+            assert False, "not implemented for now"
+        else:
+            raw_git_diffs = raw_output["all_generations"][0][generation_idx]
+            extracted_code = extract_first_code_block(
+                raw_output["all_generations"][0][generation_idx]
+            )
+            if extracted_code:
+                git_diffs = create_patch_from_code(extracted_code)
+            else:
+                git_diffs = ""
+
+        with open(args.output_file, "a") as f:
+            f.write(
+                json.dumps(
+                    {
+                        "model_name_or_path": "agentless",
+                        "instance_id": instance_id,
+                        "test_patch": git_diffs.lstrip(),
+                        "raw_test_patch": raw_git_diffs,
+                        "original_file_content": "",
+                    }
+                )
+                + "\n"
+            )
+
+
+def normalize_test(test: str):
+    def normalize_code(code):
+        try:
+            node = ast.parse(code)
+            return ast.unparse(node)
+        except:
+            return code
+
+    test = normalize_code(test)
+
+    try:
+        remove_docstring_test = remove_comments_and_docstrings(test)
+        ast.parse(remove_docstring_test)  # check
+    except:
+        remove_docstring_test = test
+
+    try:
+        test_name = remove_docstring_test.splitlines()[-1].split("(")[0]
+        remove_docstring_test = remove_docstring_test.replace(
+            test_name, "test_func"
+        )  # use generic name
+    except:
+        pass
+
+    return remove_docstring_test
+
+
+def normalize_tests(args):
+
+    selected_ids = list(range(int(args.max_samples)))
+
+    for i in selected_ids:
+        if os.path.exists(
+            f"{args.output_folder}/output_{i}_normalized_reproduction_test.jsonl"
+        ):
+            continue
+
+        tests = load_jsonl(
+            f"{args.output_folder}/output_{i}_processed_reproduction_test.jsonl"
+        )
+        for d in tests:
+            test = extract_first_code_block(d["raw_test_patch"])
+            normalized_test = normalize_test(test)
+            d["normalized_test"] = normalized_test
+
+        with open(
+            f"{args.output_folder}/output_{i}_normalized_reproduction_test.jsonl", "w"
+        ) as f:
+            for d in tests:
+                f.write(json.dumps(d) + "\n")
+
+
+def get_sample(execution_results, instance_id, sample_id) -> tuple[str, bool]:
+    """Returns the diff and pass status."""
+    return execution_results[instance_id][sample_id]
+
+
+def test_selection(args):
+    from pathlib import Path
+
+    test_exec_results = {}
+
+    roots = [Path(folder) for folder in args.output_folder.split(",")]
+
+    intervals = [(0, int(args.max_samples / len(roots)) - 1) for _ in range(len(roots))]
+
+    interval = intervals[0]
+    for i in range(interval[0], interval[1] + 1):
+        for index, root in enumerate(roots):
+            test_patches = load_jsonl(
+                f"{root}/output_{i}_normalized_reproduction_test.jsonl"
+            )
+            filtered_results = load_jsonl(
+                f"{root}/output_{i}_processed_reproduction_test_verified.jsonl"
+            )
+            print(
+                f"Loaded {len(test_patches)} patches from {root}/output_{i}_normalized.jsonl"
+            )
+            for test_patch in test_patches[:]:
+                filtered = [
+                    x
+                    for x in filtered_results
+                    if x["instance_id"] == test_patch["instance_id"]
+                ]
+                if len(filtered) != 0:
+                    filtered_status = filtered[0]["verified"]
+                else:
+                    filtered_status = False
+                test_exec_results.setdefault(test_patch["instance_id"], []).append(
+                    {
+                        "normalized_test": test_patch["normalized_test"].strip(),
+                        "test_patch": test_patch["test_patch"],
+                        "filtered_status": filtered_status,
+                    }
+                )
+
+    total_count = 0
+
+    for instance_id in test_exec_results:
+        patch_keys = [
+            test_exec_results[instance_id][i]["normalized_test"]
+            for i in range(len(test_exec_results[instance_id]))
+        ]
+        verified = [
+            test_exec_results[instance_id][i]["filtered_status"]
+            for i in range(len(test_exec_results[instance_id]))
+        ]
+
+        patch_ids = [
+            i
+            for i in range(len(test_exec_results[instance_id]))
+            if patch_keys[i].strip() and verified[i]
+        ]
+
+        if not patch_ids:
+            continue
+
+        vote = Counter()
+        first_appear_idx = dict()
+        unique_patches = set()
+        for i in patch_ids:
+            sample = get_sample(test_exec_results, instance_id, i)
+            patch_key, patch = sample["normalized_test"], sample["test_patch"]
+            vote[patch_key] += 1
+            if patch_key not in first_appear_idx:
+                first_appear_idx[patch_key] = i
+
+            unique_patches.add(patch_key)
+
+        maj_selected_id = max(
+            patch_ids,
+            key=lambda i: (vote[patch_keys[i]], -first_appear_idx[patch_keys[i]]),
+        )
+
+        print([vote[patch_keys[i]] for i in patch_ids])
+
+        sample = get_sample(test_exec_results, instance_id, maj_selected_id)
+
+        result = {
+            "model_name_or_path": "agentless",
+            "instance_id": instance_id,
+            "test_patch": sample["test_patch"],
+        }
+
+        total_count += 1
+
+        with open(f"{args.output_folder}/{args.output_file}", "a") as f:
+            f.write(json.dumps(result) + "\n")
+
+    print(total_count)
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--max_samples", type=int, default=20, help="Sampling budget.")
+    parser.add_argument(
+        "--select_id",
+        type=int,
+        default=-1,
+        help="Index the selected samples during post-processing.",
+    )
+    parser.add_argument(
+        "--model",
+        type=str,
+        default=os.getenv("AGENTLESS_MODEL", "gpt-5.2"),
+        help="Model name (defaults to $AGENTLESS_MODEL).",
+    )
+    parser.add_argument(
+        "--backend",
+        type=str,
+        default="openai",
+        choices=["openai", "deepseek", "anthropic"],
+    )
+    parser.add_argument("--output_folder", type=str, required=True)
+    parser.add_argument("--output_file", type=str)
+    parser.add_argument("--skip_greedy", action="store_true")
+    parser.add_argument(
+        "--num_threads",
+        type=int,
+        default=1,
+        help="Number of threads to use for creating API requests",
+    )
+    parser.add_argument("--target_id", type=str)
+    parser.add_argument(
+        "--mock", action="store_true", help="Mock run to compute prompt tokens."
+    )
+    parser.add_argument("--select", action="store_true")
+    parser.add_argument(
+        "--dataset",
+        type=str,
+        default="princeton-nlp/SWE-bench_Lite",
+        choices=["princeton-nlp/SWE-bench_Lite", "princeton-nlp/SWE-bench_Verified"],
+    )
+
+    args = parser.parse_args()
+
+    assert (not "deepseek" in args.model) or (
+        args.backend == "deepseek"
+    ), "Must specify `--backend deepseek` if using a DeepSeek model"
+
+    if not os.path.exists(args.output_folder):
+        os.makedirs(args.output_folder)
+    if not os.path.exists(os.path.join(args.output_folder, "generating_test_logs")):
+        os.makedirs(os.path.join(args.output_folder, "generating_test_logs"))
+
+    if not args.select:
+        args.output_file = os.path.join(args.output_folder, "output.jsonl")
+        generate_tests(args)
+        args.raw_output_file = args.output_file
+        for i in range(args.max_samples):
+            args.output_file = args.raw_output_file.replace(
+                ".jsonl", f"_{i}_processed_reproduction_test.jsonl"
+            )
+            args.select_id = i
+            post_process_tests(args)
+    else:
+        normalize_tests(args)
+        test_selection(args)
+
+
+if __name__ == "__main__":
+    main()

Repos/HWE/agents/Agentless/agentless/test/run_regression_tests.py

@@ -0,0 +1,254 @@
+import argparse
+import json
+import os
+
+import jsonlines
+from datasets import load_dataset
+from swebench.harness.constants import (
+    FAIL_TO_PASS,
+    KEY_INSTANCE_ID,
+    PASS_TO_PASS,
+    TestStatus,
+)
+from swebench.harness.grading import get_eval_tests_report, get_logs_eval
+
+from agentless.test.run_tests import run_tests
+
+
+def rewrite_report(instance_id, input_folder_path, regression_tests):
+
+    log_path = f"{input_folder_path}/test/{instance_id}/test_output.txt"
+    eval_sm, found = get_logs_eval(log_path)
+
+    eval_ref = {
+        KEY_INSTANCE_ID: instance_id,
+        FAIL_TO_PASS: [],
+        PASS_TO_PASS: regression_tests[instance_id],
+    }
+
+    report = get_eval_tests_report(eval_sm, eval_ref)
+
+    return report["PASS_TO_PASS"]["failure"]
+
+
+def save_passing_tests(output_jsonl_path, input_folder_path, dataset):
+    ds = load_dataset(dataset)
+
+    with jsonlines.open(output_jsonl_path, mode="w") as writer:
+        for entry in ds["test"]:
+            instance_id = entry["instance_id"]
+
+            log_path = f"{input_folder_path}/test/{instance_id}/test_output.txt"
+            try:
+                # obtain the list of tests that were ran
+                eval_sm, found = get_logs_eval(log_path)
+            except FileNotFoundError:
+                print(f"File not found: {log_path}")
+                continue
+
+            successful_test = []
+
+            for test_name, status in eval_sm.items():
+                # check for tests that passed
+                # NOTE: Different from `swebench.harness.grading.test_passed`, we don't collect XFAIL tests
+                # because they are expected to fail
+                if status in [TestStatus.PASSED.value]:
+                    successful_test.append(test_name)
+
+            if successful_test == []:
+                print(f"{instance_id} didn't get any passing tests")
+
+            # Create the dictionary for each entry
+            result_entry = {
+                "instance_id": instance_id,
+                "tests_passing_in_original_repo": successful_test,
+            }
+
+            # Write the entry to the JSONL file
+            writer.write(result_entry)
+
+
+def run_regression_for_each_instance(args, lines, run_id):
+
+    instance_ids = [line["instance_id"] for line in lines]
+    patches = [line["model_patch"] for line in lines]
+
+    instance_to_plausible = run_tests(
+        instance_ids,
+        patches,
+        args.num_workers,
+        run_id,
+        args.regression_tests,
+        args.instance_ids,
+        args.timeout,
+        apply_model_patch=True,
+        dataset_name=args.dataset,
+    )
+    return instance_to_plausible
+
+
+def check_if_all_instances_pass(instance_to_plausible):
+    all_passed = True
+    not_passing_instances = []
+    for key, value in instance_to_plausible.items():
+        if not value:
+            all_passed = False
+            not_passing_instances.append(key)
+
+    if all_passed:
+        print("All the chosen regression tests pass in the base repository")
+    else:
+        print(
+            f"One or more of the regression tests for instances {not_passing_instances} do not pass in the original repository"
+        )
+        print(len(not_passing_instances))
+
+
+def _run_regression(args):
+    if args.predictions_path == "gold":
+        ds = load_dataset(args.dataset)
+        instance_ids = ds["test"]["instance_id"]
+        patches = ds["test"]["patch"]
+
+        instance_to_plausible = run_tests(
+            instance_ids,
+            patches,
+            args.num_workers,
+            args.run_id,
+            args.regression_tests,
+            args.instance_ids,
+            args.timeout,
+            apply_model_patch=True,
+            dataset_name=args.dataset,
+        )
+        check_if_all_instances_pass(instance_to_plausible)
+    elif args.predictions_path:
+        assert args.predictions_path.endswith("_processed.jsonl")
+        with open(args.predictions_path, "r") as file:
+            data_lines = [json.loads(line) for line in file]
+
+        if not args.load:
+            run_regression_for_each_instance(args, data_lines, args.run_id)
+
+        regression_dict = {}
+        instance_test_dict = {}
+
+        with open(args.regression_tests, "r") as file:
+            for line in file:
+                json_obj = json.loads(line.strip())
+                instance_id = json_obj["instance_id"]
+                test = json_obj["tests_passing_in_original_repo"]
+                instance_test_dict[instance_id] = test
+
+        for data in data_lines:
+            instance_id = data["instance_id"]
+            if os.path.isfile(
+                f"logs/run_evaluation/{args.run_id}/test/{instance_id}/report.json"
+            ):
+                regression_dict[instance_id] = rewrite_report(
+                    instance_id,
+                    f"logs/run_evaluation/{args.run_id}",
+                    instance_test_dict,
+                )
+            else:
+                regression_dict[instance_id] = []
+
+        updated_data_lines = []
+        for data in data_lines:
+            instance_id = data["instance_id"]
+            if instance_id in regression_dict:
+                data["regression"] = regression_dict[instance_id]
+            updated_data_lines.append(data)
+
+        with open(
+            args.predictions_path.replace(
+                "processed.jsonl", "regression_test_results.jsonl"
+            ),
+            "w",
+        ) as file:
+            for data in updated_data_lines:
+                file.write(json.dumps(data) + "\n")
+
+    else:
+        # this is for generating a list of passing tests from the original repor
+        # TODO: some instances don't get any passing tests because some test files
+        # are renamed in the test patch and we grabbed the new file names.
+        # We can fix this by checking if a test file exists in the base repo.
+        ds = load_dataset(args.dataset)
+        instance_ids = (
+            ds["test"]["instance_id"]
+            if args.instance_ids is None
+            else args.instance_ids
+        )
+
+        # Feed in a list of blank patches
+        patches = [
+            {"instance_id": instance_id, "patch": "", "normalized_patch": ""}
+            for instance_id in instance_ids
+        ]
+
+        instance_to_plausible = run_tests(
+            instance_ids,
+            patches,
+            args.num_workers,
+            args.run_id,
+            args.regression_tests,
+            args.instance_ids,
+            args.timeout,
+            apply_model_patch=False,
+            dataset_name=args.dataset,
+        )
+
+        if args.regression_tests:
+            # check if the base repo all passes on the selected regression tests (should be true)
+            check_if_all_instances_pass(instance_to_plausible)
+
+        else:
+            # save the list of passing tests
+            save_passing_tests(
+                args.output_file,
+                os.path.join("logs", "run_evaluation", args.run_id),
+                args.dataset,
+            )
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--run_id", type=str, required=True)
+    parser.add_argument(
+        "--predictions_path",
+        type=str,
+        help="Patch file with normalized patches",
+    )
+    parser.add_argument("--output_file", type=str)
+    parser.add_argument("--regression_tests", type=str)
+    parser.add_argument("--num_workers", type=int, default=12)
+    parser.add_argument(
+        "--timeout", type=int, default=1200, help="Timeout for running tests in seconds"
+    )
+    parser.add_argument(
+        "--instance_ids",
+        nargs="+",
+        type=str,
+        help="Instance IDs to run (space separated), if not provided, all instances will be run",
+    )
+    parser.add_argument("--filter", action="store_true")
+    parser.add_argument("--load", action="store_true")
+    parser.add_argument(
+        "--dataset",
+        type=str,
+        default="princeton-nlp/SWE-bench_Lite",
+        choices=["princeton-nlp/SWE-bench_Lite", "princeton-nlp/SWE-bench_Verified"],
+    )
+
+    args = parser.parse_args()
+
+    assert not (
+        args.predictions_path and args.output_file
+    ), "An output file is only required when selecting regression tests"
+
+    _run_regression(args)
+
+
+if __name__ == "__main__":
+    main()

Repos/HWE/agents/Agentless/agentless/test/run_reproduction_tests.py

@@ -0,0 +1,170 @@
+import argparse
+import json
+import os
+
+from datasets import load_dataset
+
+from agentless.test.run_tests import run_reproduction_tests, txt_file_contains_string
+from agentless.util.utils import load_jsonl
+
+execution_results = dict()
+
+
+def run_reproduction_for_each_instance(args, lines, run_id, test_jsonl):
+
+    instance_ids = [line["instance_id"] for line in lines]
+    patches = [line["model_patch"] for line in lines]
+
+    results = run_reproduction_tests(
+        instance_ids,
+        patches,
+        args.num_workers,
+        run_id,
+        args.instance_ids,
+        args.timeout,
+        testing_patches=False,
+        apply_model_patch=True,
+        test_jsonl=test_jsonl,
+        dataset_name=args.dataset,
+    )
+    return results
+
+
+def _run_reproduction_tests(args):
+    if args.testing:
+        # for reproduction test selection
+        # run on original repo to select tests which can reproduce the issue
+        ds = load_dataset(args.dataset)
+        instance_ids = ds["test"]["instance_id"]
+        patches = [
+            {"instance_id": instance_id, "patch": "", "normalized_patch": ""}
+            for instance_id in instance_ids
+        ]
+
+        evaluation_tests = load_jsonl(args.test_jsonl)
+
+        results = run_reproduction_tests(
+            instance_ids,
+            patches,
+            args.num_workers,
+            args.run_id,
+            args.instance_ids,
+            args.timeout,
+            testing_patches=True,
+            apply_model_patch=False,
+            test_jsonl=args.test_jsonl,
+            dataset_name=args.dataset,
+        )
+
+        with open(args.test_jsonl.replace(".jsonl", "_verified.jsonl"), "w") as file:
+            for evaluation_test in evaluation_tests:
+                instance_id = evaluation_test["instance_id"]
+                if instance_id in results and results[instance_id]:
+                    evaluation_test["verified"] = True
+                    file.write(json.dumps(evaluation_test) + "\n")
+
+    elif args.predictions_path == "gold":
+        # check on groundtruth patches
+        # for evaluation purposes
+        ds = load_dataset(args.dataset)
+        instance_ids = ds["test"]["instance_id"]
+        patches = ds["test"]["patch"]
+
+        results = run_reproduction_tests(
+            instance_ids,
+            patches,
+            args.num_workers,
+            args.run_id,
+            args.instance_ids,
+            args.timeout,
+            testing_patches=False,
+            apply_model_patch=True,
+            test_jsonl=args.test_jsonl,
+            dataset_name=args.dataset,
+        )
+
+        with open(
+            "gold_production_test_results.json",
+            "w",
+        ) as file:
+            file.write(json.dumps(results))
+
+    else:
+        # run on the agentless generated patches
+        assert args.predictions_path.endswith("_processed.jsonl")
+        with open(args.predictions_path, "r") as file:
+            data_lines = [json.loads(line) for line in file]
+
+        if args.load:
+            reproduction_dict = {}
+            for data in data_lines:
+                instance_id = data["instance_id"]
+                expected_output = "Issue resolved"
+                path_to_log = f"logs/run_evaluation/{args.run_id}/test/{instance_id}/test_output.txt"
+                if os.path.isfile(path_to_log):
+                    passes_tests = txt_file_contains_string(
+                        path_to_log, expected_output
+                    )
+                    reproduction_dict[instance_id] = passes_tests
+                else:
+                    reproduction_dict[instance_id] = False
+        else:
+            reproduction_dict = run_reproduction_for_each_instance(
+                args, data_lines, args.run_id, args.test_jsonl
+            )
+
+        updated_data_lines = []
+        for data in data_lines:
+            instance_id = data["instance_id"]
+            if instance_id in reproduction_dict:
+                data["reproduction"] = reproduction_dict[instance_id]
+            updated_data_lines.append(data)
+
+        with open(
+            args.predictions_path.replace(
+                "processed.jsonl", "reproduction_test_results.jsonl"
+            ),
+            "w",
+        ) as file:
+            for data in updated_data_lines:
+                file.write(json.dumps(data) + "\n")
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--run_id", type=str, required=True)
+    parser.add_argument(
+        "--testing", action="store_true", help="If true don't apply the model patch"
+    )
+    parser.add_argument(
+        "--predictions_path",
+        type=str,
+        help="Patch file",
+    )
+    parser.add_argument("--num_workers", type=int, default=12)
+    parser.add_argument(
+        "--timeout", type=int, default=600, help="Timeout for running tests in seconds"
+    )
+    parser.add_argument(
+        "--instance_ids",
+        nargs="+",
+        type=str,
+        help="Instance IDs to run (space separated)",
+    )
+    parser.add_argument(
+        "--dataset",
+        type=str,
+        default="princeton-nlp/SWE-bench_Lite",
+        choices=["princeton-nlp/SWE-bench_Lite", "princeton-nlp/SWE-bench_Verified"],
+    )
+    parser.add_argument("--test_jsonl", type=str)
+    parser.add_argument("--load", action="store_true")
+
+    args = parser.parse_args()
+
+    # then load and run production tests on the results
+    _run_reproduction_tests(args)
+
+
+if __name__ == "__main__":
+    main()

Repos/HWE/agents/Agentless/agentless/test/run_tests.py

@@ -0,0 +1,630 @@
+import json
+import os
+import platform
+import re
+import resource
+import traceback
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from typing import Any
+
+import docker
+from swebench.harness.constants import (
+    FAIL_TO_PASS,
+    KEY_INSTANCE_ID,
+    MAP_REPO_VERSION_TO_SPECS,
+    PASS_TO_PASS,
+    USE_X86,
+    SWEbenchInstance,
+)
+from swebench.harness.docker_build import build_env_images
+from swebench.harness.run_evaluation import get_dataset_from_preds, run_instance
+from swebench.harness.test_spec import (
+    TestSpec,
+    make_env_script_list,
+    make_repo_script_list,
+)
+from swebench.harness.utils import get_test_directives
+from tqdm import tqdm
+
+OPEN_FILE_LIMIT = 4096
+
+NOOP_PATCH = """diff --git a/this_is_invisible.py b/this_is_invisible.py
+new file mode 100644
+index 0000000..e69de29
+--- /dev/null
++++ b/this_is_invisible.py
+@@ -0,0 +1 @@
++# This is a commented out line
+"""
+
+NOOP_PATCH_2 = """diff --git a/this_is_invisible_2.py b/this_is_invisible_2.py
+new file mode 100644
+index 0000000..e69de29
+--- /dev/null
++++ b/this_is_invisible_2.py
+@@ -0,0 +1 @@
++# This is a commented out line
+"""
+
+
+def remove_ansi_sequences(input_string):
+    ansi_escape_pattern = r"\x1b\[\d+m"
+    clean_string = re.sub(ansi_escape_pattern, "", input_string)
+
+    return clean_string
+
+
+def txt_file_contains_string(path_to_txt, expected_output, other_patterns=[]):
+    """
+    Check if the given text file contains the specified string.
+    :param path_to_txt: Path to the text file.
+    :param expected_output: The string to search for in the text file.
+    :return: True if the string is found in the text file, otherwise False.
+    """
+    try:
+        with open(path_to_txt, "r", encoding="utf-8") as file:
+            content = file.read()
+            filtered_content = remove_ansi_sequences(content)
+            for pattern in other_patterns:
+                if pattern in filtered_content:
+                    return False
+            return expected_output in filtered_content
+
+    except FileNotFoundError:
+        pass
+    except IOError:
+        print(f"An error occurred while reading the file at {path_to_txt}.")
+
+    return False
+
+
+def create_instance_test_dict(jsonl_file_path):
+    instance_test_dict = {}
+
+    with open(jsonl_file_path, "r") as file:
+        for line in file:
+            json_obj = json.loads(line.strip())
+            instance_id = json_obj["instance_id"]
+            test_patch = json_obj["test_patch"]
+            instance_test_dict[instance_id] = test_patch
+
+    return instance_test_dict
+
+
+def extract_resolved_info(directory_path):
+    # Check if the directory exists
+    if not os.path.exists(directory_path) or not os.path.isdir(directory_path):
+        return {}
+
+    result = {}
+    for subdir in os.listdir(directory_path):
+        subdir_path = os.path.join(directory_path, subdir)
+        if os.path.isdir(subdir_path):
+            report_path = os.path.join(subdir_path, "report.json")
+            if os.path.isfile(report_path):
+                try:
+                    with open(report_path, "r", encoding="utf-8") as report_file:
+                        data = json.load(report_file)
+                        resolved_value = data.get(subdir, {}).get("resolved", False)
+                        result[subdir] = resolved_value
+                except (json.JSONDecodeError, KeyError):
+                    result[subdir] = False
+            # else:
+            #     result[subdir] = False
+    return result
+
+
+def make_reproduction_sec(instance: SWEbenchInstance) -> TestSpec:
+    if isinstance(instance, TestSpec):
+        return instance
+    instance_id = instance[KEY_INSTANCE_ID]
+    repo = instance["repo"]
+    version = instance["version"]
+    base_commit = instance["base_commit"]
+    production_test = instance["production_test"]
+
+    def _from_json_or_obj(key: str) -> Any:
+        """If key points to string, load with json"""
+        if isinstance(instance[key], str):
+            return json.loads(instance[key])
+        return instance[key]
+
+    pass_to_pass = _from_json_or_obj(PASS_TO_PASS)
+    fail_to_pass = _from_json_or_obj(FAIL_TO_PASS)
+
+    env_name = "testbed"
+    repo_directory = f"/{env_name}"
+    specs = MAP_REPO_VERSION_TO_SPECS[repo][version]
+
+    repo_script_list = make_repo_script_list(
+        specs, repo, repo_directory, base_commit, env_name
+    )
+    env_script_list = make_env_script_list(instance, specs, env_name)
+    eval_script_list = make_reproduction_script_list(
+        instance, specs, env_name, repo_directory, base_commit, production_test
+    )
+    if platform.machine() in {"aarch64", "arm64"}:
+        # use arm64 unless explicitly specified
+        arch = "arm64" if instance_id not in USE_X86 else "x86_64"
+    else:
+        arch = "x86_64"
+
+    return TestSpec(
+        instance_id=instance_id,
+        repo=repo,
+        env_script_list=env_script_list,
+        repo_script_list=repo_script_list,
+        eval_script_list=eval_script_list,
+        version=version,
+        arch=arch,
+        FAIL_TO_PASS=fail_to_pass,
+        PASS_TO_PASS=pass_to_pass,
+    )
+
+
+def make_reproduction_script_list(
+    instance, specs, env_name, repo_directory, base_commit, reproduce_patch
+):
+    """
+    Applies new production tests and run tests
+    """
+    # Reset test files to the state they should be in before the patch.
+    reset_tests_command = f"git checkout {base_commit}"
+
+    HEREDOC_DELIMITER = "EOF_114329324912"
+    fake_apply_test_patch_command = (
+        f"git apply -v - <<'{HEREDOC_DELIMITER}'\n{NOOP_PATCH_2}\n{HEREDOC_DELIMITER}"
+    )
+
+    apply_reproduce_test_command = f"git apply -v - <<'{HEREDOC_DELIMITER}'\n{reproduce_patch}\n{HEREDOC_DELIMITER}"
+    reproduce_test_command = "python3 reproduce_bug.py"
+
+    eval_commands = [
+        f"source /opt/miniconda3/bin/activate",
+        f"conda activate {env_name}",
+        f"cd {repo_directory}",
+    ]
+    if "eval_commands" in specs:
+        eval_commands += specs["eval_commands"]
+    eval_commands += [
+        f"git config --global --add safe.directory {repo_directory}",  # for nonroot user
+        f"cd {repo_directory}",
+        # This is just informational, so we have a record
+        f"git status",
+        f"git show",
+        f"git diff {base_commit}",
+        "source /opt/miniconda3/bin/activate",
+        f"conda activate {env_name}",
+    ]
+    if "install" in specs:
+        eval_commands.append(specs["install"])
+    eval_commands += [
+        reset_tests_command,
+        fake_apply_test_patch_command,  # If we don't apply some sort of patch the harness won't return the tests which passed
+        apply_reproduce_test_command,
+        reproduce_test_command,
+        # reset_tests_command,
+    ]
+    return eval_commands
+
+
+def make_regression_spec(instance: SWEbenchInstance) -> TestSpec:
+    if isinstance(instance, TestSpec):
+        return instance
+    instance_id = instance[KEY_INSTANCE_ID]
+    repo = instance["repo"]
+    version = instance["version"]
+    base_commit = instance["base_commit"]
+
+    def _from_json_or_obj(key: str) -> Any:
+        """If key points to string, load with json"""
+        if isinstance(instance[key], str):
+            return json.loads(instance[key])
+        return instance[key]
+
+    pass_to_pass = _from_json_or_obj(PASS_TO_PASS)
+    fail_to_pass = _from_json_or_obj(FAIL_TO_PASS)
+
+    env_name = "testbed"
+    repo_directory = f"/{env_name}"
+    specs = MAP_REPO_VERSION_TO_SPECS[repo][version]
+
+    repo_script_list = make_repo_script_list(
+        specs, repo, repo_directory, base_commit, env_name
+    )
+    env_script_list = make_env_script_list(instance, specs, env_name)
+    eval_script_list = make_regression_script_list(
+        instance, specs, env_name, repo_directory, base_commit
+    )
+    if platform.machine() in {"aarch64", "arm64"}:
+        # use arm64 unless explicitly specified
+        arch = "arm64" if instance_id not in USE_X86 else "x86_64"
+    else:
+        arch = "x86_64"
+
+    return TestSpec(
+        instance_id=instance_id,
+        repo=repo,
+        env_script_list=env_script_list,
+        repo_script_list=repo_script_list,
+        eval_script_list=eval_script_list,
+        version=version,
+        arch=arch,
+        FAIL_TO_PASS=fail_to_pass,  # Remove the fail to pass cases
+        PASS_TO_PASS=pass_to_pass,
+    )
+
+
+def make_regression_script_list(instance, specs, env_name, repo_directory, base_commit):
+    """
+    Applies the test patch and runs the tests.
+    """
+    # Reset test files to the state they should be in before the patch.
+    reset_tests_command = f"git checkout {base_commit}"
+
+    HEREDOC_DELIMITER = "EOF_114329324912"
+    fake_apply_test_patch_command = (
+        f"git apply -v - <<'{HEREDOC_DELIMITER}'\n{NOOP_PATCH_2}\n{HEREDOC_DELIMITER}"
+    )
+
+    test_command = " ".join(
+        [
+            MAP_REPO_VERSION_TO_SPECS[instance["repo"]][instance["version"]][
+                "test_cmd"
+            ],
+            *get_test_directives(instance),
+        ]
+    )
+    eval_commands = [
+        "source /opt/miniconda3/bin/activate",
+        f"conda activate {env_name}",
+        f"cd {repo_directory}",
+    ]
+    if "eval_commands" in specs:
+        eval_commands += specs["eval_commands"]
+    eval_commands += [
+        f"git config --global --add safe.directory {repo_directory}",  # for nonroot user
+        f"cd {repo_directory}",
+        # This is just informational, so we have a record
+        "git status",
+        "git show",
+        f"git diff {base_commit}",
+        "source /opt/miniconda3/bin/activate",
+        f"conda activate {env_name}",
+    ]
+    if "install" in specs:
+        eval_commands.append(specs["install"])
+    eval_commands += [
+        reset_tests_command,
+        fake_apply_test_patch_command,  # If we don't apply some sort of patch the harness won't return the tests which passed
+        test_command,
+        reset_tests_command,
+    ]
+    return eval_commands
+
+
+def rearrange_patches(test_specs):
+    """
+    rearrange the patches such that slower instance_ids are evaluated first
+    this way pipelining will be faster.
+    """
+
+    slow_instance_ids = ["sympy__sympy-11870"]
+
+    slow_specs = [
+        test_spec
+        for test_spec in test_specs
+        if test_spec.instance_id in slow_instance_ids
+    ]
+
+    if len(slow_specs) != 0:
+        print(
+            f"rearrange patches such that {[x.instance_id for x in slow_specs]} are evaluated first"
+        )
+        rearranged_test_specs = slow_specs
+        for test_spec in test_specs:
+            if test_spec.instance_id not in slow_instance_ids:
+                rearranged_test_specs.append(test_spec)
+        return rearranged_test_specs
+    else:
+        return test_specs
+
+
+def run_reproduction_tests(
+    instance_ids: list,
+    model_patches: list,
+    max_workers: int,
+    run_id: str,
+    instances_to_run: list,
+    timeout: int,
+    testing_patches: bool,
+    apply_model_patch=True,
+    test_jsonl=None,
+    dataset_name="princeton-nlp/SWE-bench_Lite",
+):
+    assert len(instance_ids) == len(
+        model_patches
+    ), "There must be the same number of instance_ids as model patches"
+    resource.setrlimit(resource.RLIMIT_NOFILE, (OPEN_FILE_LIMIT, OPEN_FILE_LIMIT))
+
+    instance_to_reproduction_code = create_instance_test_dict(test_jsonl)
+
+    print(f"Using run_id: {run_id}")
+
+    split = "test"
+    client = docker.from_env()
+    force_rebuild = False
+
+    predictions = {}
+
+    for idx, one_instance_id in enumerate(instance_ids):
+        if not apply_model_patch:
+            patch_to_apply = NOOP_PATCH
+        else:
+            patch_to_apply = model_patches[idx]
+        if testing_patches:
+            predictions[one_instance_id] = {
+                "model_name_or_path": "test",
+                "model_patch": NOOP_PATCH,
+                "instance_id": one_instance_id,
+            }
+            # instance_to_reproduction_code[one_instance_id] = patch_to_apply
+        else:
+            predictions[one_instance_id] = {
+                "model_name_or_path": "test",  # TODO change.
+                "model_patch": patch_to_apply,
+                "instance_id": one_instance_id,
+            }
+
+    instances = get_dataset_from_preds(
+        dataset_name, split, instance_ids, predictions, run_id
+    )
+
+    if not instances:
+        print("No instances to run.")
+    else:
+        build_env_images(client, instances, force_rebuild, max_workers)
+
+    no_f2p_instances = []
+
+    for instance in instances:
+        revised_instance = instance
+        revised_instance["FAIL_TO_PASS"] = "[]"
+        revised_instance["PASS_TO_PASS"] = "[]"
+
+        if instance["instance_id"] in instance_to_reproduction_code:
+            revised_instance["production_test"] = instance_to_reproduction_code[
+                instance["instance_id"]
+            ]
+            # only run if there is production test
+            no_f2p_instances.append(revised_instance)
+
+    test_specs = list(map(make_reproduction_sec, no_f2p_instances))
+
+    test_specs = rearrange_patches(test_specs)
+
+    instance_image_ids = {x.instance_image_key for x in test_specs}
+    existing_images = {
+        tag
+        for i in client.images.list(all=True)
+        for tag in i.tags
+        if tag in instance_image_ids
+    }
+    print(f"Found {len(existing_images)} existing instance images. Will reuse them.")
+
+    # Load in previously evaluated results
+    resolved_dict = extract_resolved_info(
+        os.path.join("logs", "run_evaluation", run_id, "test")
+    )
+
+    if instances_to_run:
+        ids = instances_to_run
+    else:
+        ids = [
+            test_spec.instance_id
+            for test_spec in test_specs
+            if test_spec.instance_id not in list(resolved_dict.keys())
+        ]
+
+    results = {}
+
+    print(
+        f"Running {len([test_spec for test_spec in test_specs if test_spec.instance_id in ids])} unevaluated instances..."
+    )
+
+    # Set the empty instances as not resolving the issue
+    for index, patch in enumerate(model_patches):
+        if patch == "":
+            resolved_dict[instance_ids[index]] = False
+
+    with tqdm(total=len(ids), smoothing=0, colour="MAGENTA") as pbar:
+        with ThreadPoolExecutor(max_workers=max_workers) as executor:
+            # Create a future for running each instance
+            futures = {
+                executor.submit(
+                    run_instance,
+                    test_spec,
+                    predictions[test_spec.instance_id],
+                    False,  # do not remove them.
+                    force_rebuild,
+                    client,
+                    run_id,
+                    timeout,
+                ): None
+                for test_spec in test_specs
+                if test_spec.instance_id in ids
+            }
+            # Wait for each future to complete
+            for future in as_completed(futures):
+                pbar.update(1)
+                result = future.result()
+                if result:
+                    instance_id = result[0]
+                    resolved = result[1][instance_id]["resolved"]
+                    resolved_dict[instance_id] = resolved
+                    # See if the tests ran successfully
+                    if testing_patches:
+                        expected_output = "Issue reproduced"
+                        other_patterns = ["Issue resolved", "Other issues"]
+                    else:
+                        expected_output = "Issue resolved"
+                        other_patterns = ["Issue reproduced", "Other issues"]
+                    path_to_log = f"logs/run_evaluation/{run_id}/{split}/{instance_id}/test_output.txt"
+                    passes_tests = txt_file_contains_string(
+                        path_to_log, expected_output, other_patterns=other_patterns
+                    )
+                    results[instance_id] = passes_tests
+                try:
+                    # Update progress bar, check if instance ran successfully
+                    future.result()
+                except Exception as e:
+                    traceback.print_exc()
+                    results[instance_id] = False
+                    resolved_dict[instance_id] = False
+                    continue
+
+    print("All instances run.")
+    return results
+
+
+def run_tests(
+    instance_ids: list,
+    model_patches: list,
+    max_workers: int,
+    run_id: str,
+    regression_test_file: str,
+    instances_to_run: list,
+    timeout: int,
+    apply_model_patch=True,
+    dataset_name="princeton-nlp/SWE-bench_Lite",
+):
+    assert len(instance_ids) == len(
+        model_patches
+    ), "There must be the same number of instance_ids as model patches"
+    resource.setrlimit(resource.RLIMIT_NOFILE, (OPEN_FILE_LIMIT, OPEN_FILE_LIMIT))
+
+    print(f"Using run_id: {run_id}")
+
+    split = "test"
+    client = docker.from_env()
+    force_rebuild = False
+
+    predictions = {}
+
+    for idx, one_instance_id in enumerate(instance_ids):
+        if not apply_model_patch:
+            patch_to_apply = NOOP_PATCH
+        else:
+            patch_to_apply = model_patches[idx]
+        predictions[one_instance_id] = {
+            "model_name_or_path": "test",
+            "model_patch": patch_to_apply,
+            "instance_id": one_instance_id,
+        }
+
+    instances = get_dataset_from_preds(
+        dataset_name, split, instance_ids, predictions, run_id
+    )
+
+    print(f"Running {len(instances)} unevaluated instances...")
+    if not instances:
+        print("No instances to run.")
+    else:
+        build_env_images(client, instances, force_rebuild, max_workers)
+
+    instance_test_dict = {}
+
+    if regression_test_file:
+        with open(regression_test_file, "r") as file:
+            for line in file:
+                json_obj = json.loads(line.strip())
+                instance_id = json_obj["instance_id"]
+                test = json_obj["tests_passing_in_original_repo"]
+                instance_test_dict[instance_id] = test
+
+    no_f2p_instances = []
+    for instance in instances:
+        revised_instance = instance
+        revised_instance["FAIL_TO_PASS"] = "[]"
+        # DO NOT USE any of the PASS_TO_PASS in swebench
+        # it is either obtained from all passing tests (after LLM filtering)
+        # or all tests are ran
+        if regression_test_file:
+            revised_instance["PASS_TO_PASS"] = instance_test_dict[
+                instance["instance_id"]
+            ]
+        else:
+            revised_instance["PASS_TO_PASS"] = "[]"
+
+        no_f2p_instances.append(revised_instance)
+
+    test_specs = list(map(make_regression_spec, no_f2p_instances))
+
+    test_specs = rearrange_patches(test_specs)
+
+    instance_image_ids = {x.instance_image_key for x in test_specs}
+    existing_images = {
+        tag
+        for i in client.images.list(all=True)
+        for tag in i.tags
+        if tag in instance_image_ids
+    }
+    print(f"Found {len(existing_images)} existing instance images. Will reuse them.")
+
+    # Load in previously evaluated results
+    resolved_dict = extract_resolved_info(
+        os.path.join("logs", "run_evaluation", run_id, "test")
+    )
+
+    if instances_to_run:
+        ids = instances_to_run
+    else:
+        ids = [
+            test_spec.instance_id
+            for test_spec in test_specs
+            if test_spec.instance_id not in list(resolved_dict.keys())
+        ]
+
+    results = {}
+
+    # Set the empty instances as not resolving the issue
+    for index, patch in enumerate(model_patches):
+        if patch == "":
+            resolved_dict[instance_ids[index]] = False
+
+    with tqdm(total=len(ids), smoothing=0, colour="MAGENTA") as pbar:
+        with ThreadPoolExecutor(max_workers=max_workers) as executor:
+            # Create a future for running each instance
+            futures = {
+                executor.submit(
+                    run_instance,
+                    test_spec,
+                    predictions[test_spec.instance_id],
+                    False,  # do not remove them.
+                    force_rebuild,
+                    client,
+                    run_id,
+                    timeout,
+                ): None
+                for test_spec in test_specs
+                if test_spec.instance_id in ids
+            }
+            # Wait for each future to complete
+            for future in as_completed(futures):
+                pbar.update(1)
+                result = future.result()
+                if result:
+                    instance_id = result[0]
+                    resolved = result[1][instance_id]["resolved"]
+                    resolved_dict[instance_id] = resolved
+                try:
+                    # Update progress bar, check if instance ran successfully
+                    future.result()
+                except Exception as e:
+                    traceback.print_exc()
+                    results[instance_id] = False  # Or handle the error case as needed
+                    resolved_dict[instance_id] = False
+                    continue
+
+    print("All instances run.")
+    return resolved_dict

Repos/HWE/agents/Agentless/agentless/test/select_regression_tests.py

@@ -0,0 +1,220 @@
+import argparse
+import json
+import os
+
+from datasets import load_dataset
+from tqdm import tqdm
+
+from agentless.util.api_requests import num_tokens_from_messages
+from agentless.util.model import make_model
+from agentless.util.utils import load_jsonl, setup_logger
+
+MAX_CONTEXT_LENGTH = 128000
+
+
+select_tests_prompt_template = """
+We are currently solving the following issue within our repository. Here is the issue text:
+--- BEGIN ISSUE ---
+{problem_statement}
+--- END ISSUE ---
+
+Below are a list of existing tests in the repository.
+```
+{passing_tests}
+```
+
+Please identify the tests that should not be run after applying the patch to fix the issue.
+These tests should be excluded as the original functionality may change due to the patch.
+
+### Example
+```
+test1
+test2
+test5
+```
+Return only the selected tests.
+"""
+
+
+def select_test(instance_id, args, swe_bench_data, prev_o, passing_tests):
+    def _parse_model_return_lines(content: str) -> list[str]:
+        if content:
+            return content.strip().split("\n")
+
+    if args.target_id is not None:
+        if args.target_id != instance_id:
+            return
+
+    log_file = os.path.join(
+        args.output_folder, "select_test_logs", f"{instance_id}.log"
+    )
+    logger = setup_logger(log_file)
+    found = False
+    for o in prev_o:
+        if o["instance_id"] == instance_id:
+            found = True
+            break
+
+    if found:
+        logger.info(f"skipping {instance_id}")
+        return None
+
+    if len(passing_tests) == 0:
+        with open(args.output_file, "a") as f:
+            f.write(
+                json.dumps(
+                    {
+                        "instance_id": instance_id,
+                        "raw_output": "",
+                        "tests_passing_in_original_repo": passing_tests,
+                        "original_regressions": passing_tests,
+                        "traj": {},
+                    }
+                )
+                + "\n"
+            )
+        return
+
+    logger.info(f"================ selecting test for {instance_id} ================")
+
+    bench_data = [x for x in swe_bench_data if x["instance_id"] == instance_id][0]
+    problem_statement = bench_data["problem_statement"]
+
+    raw_output = ""
+
+    prompt_template = select_tests_prompt_template
+    message = prompt_template.format(
+        problem_statement=problem_statement, passing_tests="\n".join(passing_tests)
+    ).strip()
+
+    logger.info(f"prompting with message:\n{message}")
+
+    # get greedy sample
+    model = make_model(
+        model=args.model,
+        logger=logger,
+        backend=args.backend,
+        max_tokens=1024,
+        temperature=0,
+        batch_size=1,
+    )
+
+    def message_too_long(message):
+        return num_tokens_from_messages(message, args.model) >= MAX_CONTEXT_LENGTH
+
+    while message_too_long(message):
+        # half it
+        # TODO: we can prompt the model multiple times to select from different subset of tests
+        passing_tests = passing_tests[: len(passing_tests) // 2]
+        message = prompt_template.format(
+            problem_statement=problem_statement, passing_tests="\n".join(passing_tests)
+        ).strip()
+
+    greedy_traj = model.codegen(message, num_samples=1)[0]
+    greedy_traj["prompt"] = message
+    raw_output = greedy_traj["response"]
+
+    logger.info(raw_output)
+
+    model_identified_tests = _parse_model_return_lines(raw_output)
+    subset_regression_tests = []
+
+    for x in passing_tests:
+        if x not in model_identified_tests:
+            subset_regression_tests.append(x)
+
+    with open(args.output_file, "a") as f:
+        f.write(
+            json.dumps(
+                {
+                    "instance_id": instance_id,
+                    "raw_output": raw_output,
+                    "tests_passing_in_original_repo": subset_regression_tests,
+                    "original_regressions": passing_tests,
+                    "traj": greedy_traj,
+                }
+            )
+            + "\n"
+        )
+
+
+def select_tests(args):
+    with open(f"{args.output_folder}/args.json", "w") as f:
+        json.dump(vars(args), f, indent=4)
+
+    instance_test_dict = {}
+    with open(args.passing_tests, "r") as file:
+        for line in file:
+            json_obj = json.loads(line.strip())
+            instance_id = json_obj["instance_id"]
+            test = json_obj["tests_passing_in_original_repo"]
+            instance_test_dict[instance_id] = test
+
+    swe_bench_data = load_dataset(args.dataset, split="test")
+    instance_ids = (
+        swe_bench_data["instance_id"]
+        if args.instance_ids is None
+        else args.instance_ids
+    )
+    prev_o = load_jsonl(args.output_file) if os.path.exists(args.output_file) else []
+
+    results = []
+
+    for instance_id in tqdm(instance_ids, total=len(instance_ids), colour="MAGENTA"):
+        result = select_test(
+            instance_id, args, swe_bench_data, prev_o, instance_test_dict[instance_id]
+        )
+        if result is not None:
+            results.append(result)
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--model",
+        type=str,
+        default=os.getenv("AGENTLESS_MODEL", "gpt-5.2"),
+        help="Model name (defaults to $AGENTLESS_MODEL).",
+    )
+    parser.add_argument(
+        "--backend",
+        type=str,
+        default="openai",
+        choices=["openai", "deepseek", "anthropic"],
+    )
+    parser.add_argument("--output_folder", type=str, required=True)
+    parser.add_argument("--target_id", type=str)
+    parser.add_argument(
+        "--mock", action="store_true", help="Mock run to compute prompt tokens."
+    )
+    parser.add_argument(
+        "--dataset",
+        type=str,
+        default="princeton-nlp/SWE-bench_Lite",
+        choices=["princeton-nlp/SWE-bench_Lite", "princeton-nlp/SWE-bench_Verified"],
+    )
+    parser.add_argument(
+        "--instance_ids",
+        nargs="+",
+        type=str,
+        help="Instance IDs to run (space separated), if not provided, all instances will be run",
+    )
+    parser.add_argument("--passing_tests", type=str, required=True)
+
+    args = parser.parse_args()
+
+    assert (not "deepseek" in args.model) or (
+        args.backend == "deepseek"
+    ), "Must specify `--backend deepseek` if using a DeepSeek model"
+
+    if not os.path.exists(args.output_folder):
+        os.makedirs(args.output_folder)
+    if not os.path.exists(os.path.join(args.output_folder, "select_test_logs")):
+        os.makedirs(os.path.join(args.output_folder, "select_test_logs"))
+
+    args.output_file = os.path.join(args.output_folder, "output.jsonl")
+    select_tests(args)
+
+
+if __name__ == "__main__":
+    main()

Repos/HWE/agents/Agentless/agentless/util/api_requests.py

@@ -0,0 +1,192 @@
+import os
+import time
+from typing import Dict, Union
+
+import anthropic
+import openai
+import tiktoken
+
+
+DEFAULT_AGENTLESS_MODEL = os.getenv("AGENTLESS_MODEL", "gpt-5.2")
+
+
+def _resolve_model_name(model: Union[str, None]) -> str:
+    return model or os.getenv("AGENTLESS_MODEL", DEFAULT_AGENTLESS_MODEL)
+
+
+def num_tokens_from_messages(message, model: Union[str, None] = None):
+    """Returns the number of tokens used by a list of messages."""
+    model = _resolve_model_name(model)
+    try:
+        encoding = tiktoken.encoding_for_model(model)
+    except KeyError:
+        encoding = tiktoken.get_encoding("cl100k_base")
+    if isinstance(message, list):
+        # use last message.
+        num_tokens = len(encoding.encode(message[0]["content"]))
+    else:
+        num_tokens = len(encoding.encode(message))
+    return num_tokens
+
+
+def create_chatgpt_config(
+    message: Union[str, list],
+    max_tokens: int,
+    temperature: float = 1,
+    batch_size: int = 1,
+    system_message: str = "You are a helpful assistant.",
+    model: Union[str, None] = None,
+) -> Dict:
+    model = _resolve_model_name(model)
+    if isinstance(message, list):
+        config = {
+            "model": model,
+            "max_tokens": max_tokens,
+            "temperature": temperature,
+            "n": batch_size,
+            "messages": [{"role": "system", "content": system_message}] + message,
+        }
+    else:
+        config = {
+            "model": model,
+            "max_tokens": max_tokens,
+            "temperature": temperature,
+            "n": batch_size,
+            "messages": [
+                {"role": "system", "content": system_message},
+                {"role": "user", "content": message},
+            ],
+        }
+    return config
+
+
+def handler(signum, frame):
+    # swallow signum and frame
+    raise Exception("end of time")
+
+
+def request_chatgpt_engine(config, logger, base_url="https://api.openai.com/v1", max_retries=40, timeout=100):
+    ret = None
+    retries = 0
+    last_exception = None
+    
+    base_url = os.getenv("OPENAI_API_BASE", base_url)
+
+    client = openai.OpenAI(base_url=base_url)
+
+    while ret is None and retries < max_retries:
+        try:
+            # Attempt to get the completion
+            logger.info("Creating API request")
+
+            ret = client.chat.completions.create(**config)
+
+        except openai.OpenAIError as e:
+            last_exception = e
+            if isinstance(e, openai.BadRequestError):
+                logger.info("Request invalid")
+                print(e)
+                logger.info(e)
+                raise Exception("Invalid API Request")
+            elif isinstance(e, openai.RateLimitError):
+                print("Rate limit exceeded. Waiting...")
+                logger.info("Rate limit exceeded. Waiting...")
+                print(e)
+                logger.info(e)
+                time.sleep(5)
+            elif isinstance(e, openai.APIConnectionError):
+                print("API connection error. Waiting...")
+                logger.info("API connection error. Waiting...")
+                print(e)
+                logger.info(e)
+                time.sleep(5)
+            else:
+                print("Unknown error. Waiting...")
+                logger.info("Unknown error. Waiting...")
+                print(e)
+                logger.info(e)
+                time.sleep(1)
+        except Exception as e:
+            last_exception = e
+            logger.exception("Unexpected exception during API request")
+            time.sleep(1)
+
+        retries += 1
+
+    if ret is None:
+        if last_exception is not None:
+            logger.error(
+                "API request failed after %s retries; last error: %s",
+                retries,
+                repr(last_exception),
+            )
+        else:
+            logger.error("API request failed after %s retries with no response.", retries)
+    logger.info(f"API response {ret}")
+    return ret
+
+
+def create_anthropic_config(
+    message: str,
+    max_tokens: int,
+    temperature: float = 1,
+    batch_size: int = 1,
+    system_message: str = "You are a helpful assistant.",
+    model: Union[str, None] = None,
+    tools: list = None,
+) -> Dict:
+    model = _resolve_model_name(model)
+    if isinstance(message, list):
+        config = {
+            "model": model,
+            "temperature": temperature,
+            "max_tokens": max_tokens,
+            "messages": message,
+        }
+    else:
+        config = {
+            "model": model,
+            "temperature": temperature,
+            "max_tokens": max_tokens,
+            "messages": [
+                {"role": "user", "content": [{"type": "text", "text": message}]},
+            ],
+        }
+
+    if tools:
+        config["tools"] = tools
+
+    return config
+
+
+def request_anthropic_engine(
+    config, logger, max_retries=40, timeout=500, prompt_cache=False
+):
+    ret = None
+    retries = 0
+
+    client = anthropic.Anthropic()
+
+    while ret is None and retries < max_retries:
+        try:
+            start_time = time.time()
+            if prompt_cache:
+                # following best practice to cache mainly the reused content at the beginning
+                # this includes any tools, system messages (which is already handled since we try to cache the first message)
+                config["messages"][0]["content"][0]["cache_control"] = {
+                    "type": "ephemeral"
+                }
+                ret = client.beta.prompt_caching.messages.create(**config)
+            else:
+                ret = client.messages.create(**config)
+        except Exception as e:
+            logger.error("Unknown error. Waiting...", exc_info=True)
+            # Check if the timeout has been exceeded
+            if time.time() - start_time >= timeout:
+                logger.warning("Request timed out. Retrying...")
+            else:
+                logger.warning("Retrying after an unknown error...")
+            time.sleep(10 * retries)
+        retries += 1
+
+    return ret

Repos/HWE/agents/Agentless/agentless/util/compress_file.py

@@ -0,0 +1,220 @@
+import re
+
+import libcst as cst
+import libcst.matchers as m
+
+
+class CompressTransformer(cst.CSTTransformer):
+    DESCRIPTION = str = "Replaces function body with ..."
+    replacement_string = '"__FUNC_BODY_REPLACEMENT_STRING__"'
+
+    def __init__(self, keep_constant=True, keep_indent=False):
+        self.keep_constant = keep_constant
+        self.keep_indent = keep_indent
+
+    def leave_Module(
+        self, original_node: cst.Module, updated_node: cst.Module
+    ) -> cst.Module:
+        new_body = [
+            stmt
+            for stmt in updated_node.body
+            if m.matches(stmt, m.ClassDef())
+            or m.matches(stmt, m.FunctionDef())
+            or (
+                self.keep_constant
+                and m.matches(stmt, m.SimpleStatementLine())
+                and m.matches(stmt.body[0], m.Assign())
+            )
+        ]
+        return updated_node.with_changes(body=new_body)
+
+    def leave_ClassDef(
+        self, original_node: cst.ClassDef, updated_node: cst.ClassDef
+    ) -> cst.ClassDef:
+        # Remove docstring in the class body
+        new_body = [
+            stmt
+            for stmt in updated_node.body.body
+            if not (
+                m.matches(stmt, m.SimpleStatementLine())
+                and m.matches(stmt.body[0], m.Expr())
+                and m.matches(stmt.body[0].value, m.SimpleString())
+            )
+        ]
+        return updated_node.with_changes(body=cst.IndentedBlock(body=new_body))
+
+    def leave_FunctionDef(
+        self, original_node: cst.FunctionDef, updated_node: cst.FunctionDef
+    ) -> cst.CSTNode:
+        if not self.keep_indent:
+            # replace with unindented statement
+            new_expr = cst.Expr(value=cst.SimpleString(value=self.replacement_string))
+            new_body = cst.IndentedBlock((new_expr,))
+            return updated_node.with_changes(body=new_body)
+        else:
+            # replace with indented statement
+            # new_expr = [cst.Pass()]
+            new_expr = [
+                cst.Expr(value=cst.SimpleString(value=self.replacement_string)),
+            ]
+            return updated_node.with_changes(
+                body=cst.IndentedBlock(body=[cst.SimpleStatementLine(body=new_expr)])
+            )
+
+
+class GlobalVariableVisitor(cst.CSTVisitor):
+    METADATA_DEPENDENCIES = (cst.metadata.PositionProvider,)
+
+    def __init__(self):
+        self.assigns = []
+
+    def leave_Assign(self, original_node: cst.Module) -> list:
+        stmt = original_node
+        start_pos = self.get_metadata(cst.metadata.PositionProvider, stmt).start
+        end_pos = self.get_metadata(cst.metadata.PositionProvider, stmt).end
+        self.assigns.append([stmt, start_pos, end_pos])
+
+
+code = """
+\"\"\"
+this is a module
+...
+\"\"\"
+const = {1,2,3}
+import os
+
+class fooClass:
+    '''this is a class'''
+
+    def __init__(self, x):
+        '''initialization.'''
+        self.x = x
+
+    def print(self):
+        print(self.x)
+
+large_var = {
+    1: 2,
+    2: 3,
+    3: 4,
+    4: 5,
+    5: 6,
+    6: 7,
+    7: 8,
+    8: 9,
+    9: 10,
+    10: 11,
+    11: 12,
+    12: 13,
+    13: 14,
+    14: 15,
+    15: 16,
+    16: 17,
+    17: 18,
+    18: 19,
+    19: 20,
+    20: 21,
+}
+
+def test():
+    a = fooClass(3)
+    a.print()
+
+"""
+
+
+def remove_lines(raw_code, remove_line_intervals):
+    # TODO: speed up this function
+    # remove_line_intervals.sort()
+
+    # Remove lines
+    new_code = ""
+    for i, line in enumerate(raw_code.splitlines()):
+        # intervals are one-based
+        if not any(start <= i + 1 <= end for start, end in remove_line_intervals):
+            new_code += line + "\n"
+        if any(start == i + 1 for start, _ in remove_line_intervals):
+            new_code += "...\n"
+    return new_code
+
+
+def compress_assign_stmts(raw_code, total_lines=30, prefix_lines=10, suffix_lines=10):
+    try:
+        tree = cst.parse_module(raw_code)
+    except Exception as e:
+        print(e.__class__.__name__, e)
+        return raw_code
+
+    wrapper = cst.metadata.MetadataWrapper(tree)
+    visitor = GlobalVariableVisitor()
+    wrapper.visit(visitor)
+
+    remove_line_intervals = []
+    for stmt in visitor.assigns:
+        if stmt[2].line - stmt[1].line > total_lines:
+            remove_line_intervals.append(
+                (stmt[1].line + prefix_lines, stmt[2].line - suffix_lines)
+            )
+    return remove_lines(raw_code, remove_line_intervals)
+
+
+def get_skeleton(
+    raw_code,
+    keep_constant: bool = True,
+    keep_indent: bool = False,
+    compress_assign: bool = False,
+    total_lines=30,
+    prefix_lines=10,
+    suffix_lines=10,
+):
+    try:
+        tree = cst.parse_module(raw_code)
+    except:
+        return raw_code
+
+    transformer = CompressTransformer(keep_constant=keep_constant, keep_indent=True)
+    modified_tree = tree.visit(transformer)
+    code = modified_tree.code
+
+    if compress_assign:
+        code = compress_assign_stmts(
+            code,
+            total_lines=total_lines,
+            prefix_lines=prefix_lines,
+            suffix_lines=suffix_lines,
+        )
+
+    if keep_indent:
+        code = code.replace(CompressTransformer.replacement_string + "\n", "...\n")
+        code = code.replace(CompressTransformer.replacement_string, "...\n")
+    else:
+        pattern = f"\\n[ \\t]*{CompressTransformer.replacement_string}"
+        replacement = "\n..."
+        code = re.sub(pattern, replacement, code)
+
+    return code
+
+
+def test_compress():
+    skeleton = get_skeleton(code, True)
+    print(skeleton)
+
+
+def test_compress_var():
+    print("LOC: ", len(code.split("\n")))
+    skeleton = get_skeleton(
+        code,
+        True,
+        keep_indent=False,
+        compress_assign=True,
+        total_lines=10,
+        prefix_lines=5,
+        suffix_lines=5,
+    )
+    print(skeleton)
+    print("LOC: ", len(skeleton.split("\n")))
+
+
+if __name__ == "__main__":
+    # test_compress()
+    test_compress_var()

Repos/HWE/agents/Agentless/agentless/util/index_skeleton.py

@@ -0,0 +1,73 @@
+import libcst as cst
+import libcst.matchers as m
+
+
+class GlobalVisitor(cst.CSTVisitor):
+    METADATA_DEPENDENCIES = (cst.metadata.PositionProvider,)
+
+    def __init__(self):
+        # includes both imports and assigns
+        self.global_stmt = []
+        self.global_imports = []
+
+    def leave_Module(self, original_node: cst.Module) -> list:
+        for stmt in original_node.body:
+            if m.matches(stmt, m.SimpleStatementLine()) and (
+                m.matches(stmt.body[0], m.Assign())
+            ):
+                expr = cst.parse_module("").code_for_node(stmt).strip()
+                self.global_stmt.append(expr)
+
+            if m.matches(stmt, m.SimpleStatementLine()) and (
+                m.matches(stmt.body[0], m.Import())
+                or m.matches(stmt.body[0], m.ImportFrom())
+            ):
+                expr = cst.parse_module("").code_for_node(stmt).strip()
+                self.global_imports.append(expr)
+
+
+def parse_global_stmt_from_code(file_content: str) -> tuple[str, str]:
+    """Parse global variables."""
+    try:
+        tree = cst.parse_module(file_content)
+        wrapper = cst.metadata.MetadataWrapper(tree)
+        visitor = GlobalVisitor()
+        wrapper.visit(visitor)
+
+        return "\n".join(visitor.global_stmt), "\n".join(visitor.global_imports)
+    except:
+        return "", ""
+
+
+code = """
+\"\"\"
+this is a module
+...
+\"\"\"
+const = {1,2,3}
+import os
+from ds import get
+from ds import *
+class fooClass:
+    '''this is a class'''
+
+    def __init__(self, x):
+        '''initialization.'''
+        self.x = x
+
+    def print(self):
+        print(self.x)
+
+def test():
+    a = fooClass(3)
+    a.print()
+"""
+
+
+def test_parse():
+    global_stmt = parse_global_stmt_from_code(code)
+    print(global_stmt)
+
+
+if __name__ == "__main__":
+    test_parse()

Repos/HWE/agents/Agentless/agentless/util/model.py

@@ -0,0 +1,421 @@
+import json
+from abc import ABC, abstractmethod
+from typing import List
+
+from agentless.util.api_requests import (
+    create_anthropic_config,
+    create_chatgpt_config,
+    request_anthropic_engine,
+    request_chatgpt_engine,
+)
+
+
+class DecoderBase(ABC):
+    def __init__(
+        self,
+        name: str,
+        logger,
+        batch_size: int = 1,
+        temperature: float = 0.8,
+        max_new_tokens: int = 1024,
+    ) -> None:
+        logger.info("Initializing a decoder model: {} ...".format(name))
+        self.name = name
+        self.logger = logger
+        self.batch_size = batch_size
+        self.temperature = temperature
+        self.max_new_tokens = max_new_tokens
+
+    @abstractmethod
+    def codegen(
+        self, message: str, num_samples: int = 1, prompt_cache: bool = False
+    ) -> List[dict]:
+        pass
+
+    @abstractmethod
+    def is_direct_completion(self) -> bool:
+        pass
+
+    def __repr__(self) -> str:
+        return self.name
+
+    def __str__(self) -> str:
+        return self.name
+
+
+class OpenAIChatDecoder(DecoderBase):
+    def __init__(self, name: str, logger, **kwargs) -> None:
+        super().__init__(name, logger, **kwargs)
+
+    def codegen(
+        self, message: str, num_samples: int = 1, prompt_cache: bool = False
+    ) -> List[dict]:
+        if self.temperature == 0:
+            assert num_samples == 1
+        batch_size = min(self.batch_size, num_samples)
+
+        config = create_chatgpt_config(
+            message=message,
+            max_tokens=self.max_new_tokens,
+            temperature=self.temperature,
+            batch_size=batch_size,
+            model=self.name,
+        )
+        ret = request_chatgpt_engine(config, self.logger)
+        if ret:
+            responses = [choice.message.content for choice in ret.choices]
+            completion_tokens = ret.usage.completion_tokens
+            prompt_tokens = ret.usage.prompt_tokens
+        else:
+            self.logger.error("No API response returned; see prior logs for errors.")
+            responses = [""]
+            completion_tokens = 0
+            prompt_tokens = 0
+
+        # The nice thing is, when we generate multiple samples from the same input (message),
+        # the input tokens are only charged once according to openai API.
+        # Therefore, we assume the request cost is only counted for the first sample.
+        # More specifically, the `prompt_tokens` is for one input message,
+        # and the `completion_tokens` is the sum of all returned completions.
+        # Therefore, for the second and later samples, the cost is zero.
+        trajs = [
+            {
+                "response": responses[0],
+                "usage": {
+                    "completion_tokens": completion_tokens,
+                    "prompt_tokens": prompt_tokens,
+                },
+            }
+        ]
+        for response in responses[1:]:
+            trajs.append(
+                {
+                    "response": response,
+                    "usage": {
+                        "completion_tokens": 0,
+                        "prompt_tokens": 0,
+                    },
+                }
+            )
+        return trajs
+
+    def is_direct_completion(self) -> bool:
+        return False
+
+
+class AnthropicChatDecoder(DecoderBase):
+    def __init__(self, name: str, logger, **kwargs) -> None:
+        super().__init__(name, logger, **kwargs)
+
+    _STR_REPLACE_EDITOR_DESCRIPTION = """Custom editing tool for editing files
+* State is persistent across command calls and discussions with the user
+
+Notes for using the `str_replace` command:
+* The `old_str` parameter should match EXACTLY one or more consecutive lines from the original file. Be mindful of whitespaces!
+* If the `old_str` parameter is not unique in the file, the replacement will not be performed. Make sure to include enough context in `old_str` to make it unique
+* The `new_str` parameter should contain the edited lines that should replace the `old_str`
+"""
+
+    _USER_REPLY_EDIT_MESSAGE = """File is successfully edited"""
+
+    tools = [
+        {
+            "name": "str_replace_editor",
+            "description": _STR_REPLACE_EDITOR_DESCRIPTION,
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "path": {
+                        "description": "Full path to file, e.g. `folder/file.py`.",
+                        "type": "string",
+                    },
+                    "old_str": {
+                        "description": "Required parameter containing the string in `path` to replace.",
+                        "type": "string",
+                    },
+                    "new_str": {
+                        "description": "Optional parameter containing the new string (if not given, no string will be added).",
+                        "type": "string",
+                    },
+                },
+                "required": ["path", "old_str"],
+            },
+        }
+    ]
+
+    MAX_CODEGEN_ITERATIONS = 10
+
+    # specialized codegen with tool
+    def codegen_w_tool(
+        self, message: str, num_samples: int = 1, prompt_cache: bool = False
+    ) -> List[dict]:
+        def _build_response_and_extract(response, messages, iter):
+            json_response = response.to_dict()
+
+            contains_tool = False
+            # formulate the messages
+            json_response.pop("id")
+            json_response.pop("model")
+            json_response.pop("stop_reason")
+            json_response.pop("stop_sequence")
+            json_response.pop("type")
+            json_response.pop("usage")
+
+            messages.append(json_response)
+
+            response_content = []
+
+            for json_message in json_response["content"]:
+                if json_message["type"] == "tool_use":
+                    contains_tool = True
+                    # each tool use requires a response
+                    response_content.append(
+                        {
+                            "type": "tool_result",
+                            "tool_use_id": json_message["id"],
+                            "content": self._USER_REPLY_EDIT_MESSAGE,
+                        }
+                    )
+
+            if contains_tool:
+                messages.append(
+                    {
+                        "role": "user",
+                        "content": response_content,
+                    }
+                )
+            else:
+                if iter == 0:
+                    # if the first iteration does not contain the tool, likely the model is doing some CoT for debugging
+                    # append encouraging message
+                    messages.append(
+                        {
+                            "role": "user",
+                            "content": [
+                                {
+                                    "type": "text",
+                                    "text": "Please generate editing commands to fix the issue",
+                                }
+                            ],
+                        }
+                    )
+                    contains_tool = True
+
+            return messages, contains_tool
+
+        if self.temperature == 0:
+            assert num_samples == 1
+
+        trajs = []
+        for _ in range(num_samples):
+            self.logger.info(f" === Generating ====")
+            # initialized the traj
+            traj = {
+                "response": [],
+                "usage": {
+                    "completion_tokens": 0,
+                    "prompt_tokens": 0,
+                    "cache_creation_token": 0,
+                    "cache_read_input_tokens": 0,
+                },
+            }
+
+            # create the initial config and messages
+            messages = [
+                {"role": "user", "content": [{"type": "text", "text": message}]}
+            ]
+
+            for iteration in range(self.MAX_CODEGEN_ITERATIONS):
+                config = create_anthropic_config(
+                    message=messages,
+                    max_tokens=self.max_new_tokens,
+                    temperature=self.temperature,
+                    batch_size=1,
+                    model=self.name,
+                    tools=self.tools,
+                )
+                ret = request_anthropic_engine(
+                    config,
+                    self.logger,
+                    prompt_cache=True,  # prompt cache should be always true as we at least should query twice
+                )
+
+                if ret:
+                    # add the response to the traj
+                    traj["response"].append([reply.to_dict() for reply in ret.content])
+
+                    # pretty dump the response
+                    for reply in ret.content:
+                        self.logger.info(json.dumps(reply.to_dict(), indent=2))
+
+                    # update the usage
+                    traj["usage"]["completion_tokens"] += ret.usage.output_tokens
+                    traj["usage"]["prompt_tokens"] += ret.usage.input_tokens
+                    traj["usage"][
+                        "cache_creation_token"
+                    ] += ret.usage.cache_creation_input_tokens
+                    traj["usage"][
+                        "cache_read_input_tokens"
+                    ] += ret.usage.cache_read_input_tokens
+
+                    messages, contains_tool = _build_response_and_extract(
+                        ret, messages, iteration
+                    )
+
+                    if not contains_tool:
+                        break
+                else:
+                    assert (
+                        False
+                    ), "No response from the engine"  # this should not happen
+
+            if ret:
+                trajs.append(traj)
+            else:
+                trajs.append(
+                    {
+                        "response": "",
+                        "usage": {
+                            "completion_tokens": 0,
+                            "prompt_tokens": 0,
+                        },
+                    }
+                )
+
+        return trajs
+
+    def codegen(
+        self, message: str, num_samples: int = 1, prompt_cache: bool = False
+    ) -> List[dict]:
+        if self.temperature == 0:
+            assert num_samples == 1
+
+        trajs = []
+        for _ in range(num_samples):
+            config = create_anthropic_config(
+                message=message,
+                max_tokens=self.max_new_tokens,
+                temperature=self.temperature,
+                batch_size=1,
+                model=self.name,
+            )
+            ret = request_anthropic_engine(
+                config, self.logger, prompt_cache=prompt_cache
+            )
+
+            if ret:
+                trajs.append(
+                    {
+                        "response": ret.content[0].text,
+                        "usage": {
+                            "completion_tokens": ret.usage.output_tokens,
+                            "prompt_tokens": ret.usage.input_tokens,
+                            "cache_creation_token": 0
+                            if not prompt_cache
+                            else ret.usage.cache_creation_input_tokens,
+                            "cache_read_input_tokens": 0
+                            if not prompt_cache
+                            else ret.usage.cache_read_input_tokens,
+                        },
+                    }
+                )
+            else:
+                trajs.append(
+                    {
+                        "response": "",
+                        "usage": {
+                            "completion_tokens": 0,
+                            "prompt_tokens": 0,
+                        },
+                    }
+                )
+
+        return trajs
+
+    def is_direct_completion(self) -> bool:
+        return False
+
+
+class DeepSeekChatDecoder(DecoderBase):
+    def __init__(self, name: str, logger, **kwargs) -> None:
+        super().__init__(name, logger, **kwargs)
+
+    def codegen(
+        self, message: str, num_samples: int = 1, prompt_cache: bool = False
+    ) -> List[dict]:
+        if self.temperature == 0:
+            assert num_samples == 1
+
+        trajs = []
+        for _ in range(num_samples):
+            config = create_chatgpt_config(
+                message=message,
+                max_tokens=self.max_new_tokens,
+                temperature=self.temperature,
+                batch_size=1,
+                model=self.name,
+            )
+            ret = request_chatgpt_engine(
+                config, self.logger, base_url="https://api.deepseek.com"
+            )
+            if ret:
+                trajs.append(
+                    {
+                        "response": ret.choices[0].message.content,
+                        "usage": {
+                            "completion_tokens": ret.usage.completion_tokens,
+                            "prompt_tokens": ret.usage.prompt_tokens,
+                        },
+                    }
+                )
+            else:
+                trajs.append(
+                    {
+                        "response": "",
+                        "usage": {
+                            "completion_tokens": 0,
+                            "prompt_tokens": 0,
+                        },
+                    }
+                )
+
+        return trajs
+
+    def is_direct_completion(self) -> bool:
+        return False
+
+
+def make_model(
+    model: str,
+    backend: str,
+    logger,
+    batch_size: int = 1,
+    max_tokens: int = 1024,
+    temperature: float = 0.0,
+):
+    if backend == "openai":
+        return OpenAIChatDecoder(
+            name=model,
+            logger=logger,
+            batch_size=batch_size,
+            max_new_tokens=max_tokens,
+            temperature=temperature,
+        )
+    elif backend == "anthropic":
+        return AnthropicChatDecoder(
+            name=model,
+            logger=logger,
+            batch_size=batch_size,
+            max_new_tokens=max_tokens,
+            temperature=temperature,
+        )
+    elif backend == "deepseek":
+        return DeepSeekChatDecoder(
+            name=model,
+            logger=logger,
+            batch_size=batch_size,
+            max_new_tokens=max_tokens,
+            temperature=temperature,
+        )
+    else:
+        raise NotImplementedError

Repos/HWE/agents/Agentless/agentless/util/parse_global_var.py

@@ -0,0 +1,93 @@
+import libcst as cst
+import libcst.matchers as m
+from libcst.display import dump
+
+
+class GlobalVariableVisitor(cst.CSTVisitor):
+    METADATA_DEPENDENCIES = (cst.metadata.PositionProvider,)
+
+    def __init__(self):
+        self.global_assigns = []
+
+    def leave_Module(self, original_node: cst.Module) -> list:
+        assigns = []
+        for stmt in original_node.body:
+            if m.matches(stmt, m.SimpleStatementLine()) and m.matches(
+                stmt.body[0], m.Assign()
+            ):
+                start_pos = self.get_metadata(cst.metadata.PositionProvider, stmt).start
+                end_pos = self.get_metadata(cst.metadata.PositionProvider, stmt).end
+                assigns.append([stmt, start_pos, end_pos])
+        self.global_assigns.extend(assigns)
+
+
+def parse_global_var_from_code(file_content: str) -> dict[str, dict]:
+    """Parse global variables."""
+    try:
+        tree = cst.parse_module(file_content)
+    except:
+        return file_content
+
+    wrapper = cst.metadata.MetadataWrapper(tree)
+    visitor = GlobalVariableVisitor()
+    wrapper.visit(visitor)
+
+    global_assigns = {}
+    for assign_stmt, start_pos, end_pos in visitor.global_assigns:
+        for t in assign_stmt.body:
+            try:
+                targets = [t.targets[0].target.value]
+            except:
+                try:
+                    targets = t.targets[0].target.elements
+                    targets = [x.value.value for x in targets]
+                except:
+                    targets = []
+            for target_var in targets:
+                global_assigns[target_var] = {
+                    "start_line": start_pos.line,
+                    "end_line": end_pos.line,
+                }
+    return global_assigns
+
+
+def test_parse_global_var_from_file():
+    code = """
+\"\"\"
+this is a module
+...
+\"\"\"
+const_var = {1,2,3}
+const_dict = {
+    'day': 'Monday',
+    'month': 'January',
+}
+a, b = 1, 2
+import os
+
+class fooClass:
+    '''this is a class'''
+
+    def __init__(self, x):
+        '''initialization.'''
+        self.x = x
+
+    def print(self):
+        print(self.x)
+
+def test():
+    a = fooClass(3)
+    a.print()
+
+"""
+    res = parse_global_var_from_code(code)
+    assert res == {
+        "const_var": {"start_line": 6, "end_line": 6},
+        "const_dict": {"start_line": 7, "end_line": 10},
+        "a": {"start_line": 11, "end_line": 11},
+        "b": {"start_line": 11, "end_line": 11},
+    }
+
+
+if __name__ == "__main__":
+    test_parse_global_var_from_file()

Repos/HWE/agents/Agentless/agentless/util/postprocess_data.py

@@ -0,0 +1,1176 @@
+import ast
+import os
+import re
+import subprocess
+import uuid
+from collections import OrderedDict
+
+from get_repo_structure.get_patch_info import parse_patch
+
+SOURCE_EXTENSIONS = {".py", ".v", ".sv", ".vh", ".svh"}
+LOC_PREFIXES = (
+    "line:",
+    "function:",
+    "task:",
+    "method:",
+    "class:",
+    "module:",
+    "interface:",
+    "package:",
+    "program:",
+    "checker:",
+    "config:",
+    "primitive:",
+    "udp:",
+    "variable:",
+)
+
+
+def _looks_like_verilog(code: str) -> bool:
+    sample = "\n".join(code.splitlines()[:50]).lower()
+    if "`timescale" in sample or "`include" in sample:
+        return True
+    return re.search(
+        r"\b(module|endmodule|interface|endinterface|package|endpackage|always_ff|always_comb|logic|wire|reg|assign)\b",
+        sample,
+    ) is not None
+
+
+def _is_source_path(line, file_names):
+    if line in file_names:
+        return True
+    _, ext = os.path.splitext(line)
+    return ext.lower() in SOURCE_EXTENSIONS
+
+
+def check_syntax(code):
+    if not isinstance(code, list):
+        code = [code]
+
+    for c in code:
+        if (
+            not c.strip()
+        ):  # Check for cases where the model didn't return a python block
+            return False
+        try:
+            ast.parse(c)
+        except SyntaxError as e:
+            if _looks_like_verilog(c):
+                continue
+            return False
+    return True
+
+
+def remove_empty_lines(code: str) -> str:
+    # Split the code into lines
+    lines = code.splitlines()
+    # Remove empty lines
+    filtered_lines = [line for line in lines if line.strip() != ""]
+    return "\n".join(filtered_lines)
+
+
+def check_code_differ_by_just_empty_lines(codes, prev_codes) -> bool:
+
+    if not isinstance(codes, list):
+        codes = [codes]
+        prev_codes = [prev_codes]
+
+    normalized_code1 = ""
+    normalized_code2 = ""
+
+    for code, prev_code in zip(codes, prev_codes):
+        # Normalize both code snippets
+        normalized_code1 += remove_empty_lines(code)
+        normalized_code2 += remove_empty_lines(prev_code)
+
+    return normalized_code1 == normalized_code2
+
+
+def lint_code(repo_playground, temp_name, code, prev_code="") -> tuple[bool, set, set]:
+
+    # Generate a temperary folder and add uuid to avoid collision
+    repo_playground = os.path.join(repo_playground, str(uuid.uuid4()))
+
+    # assert playground doesn't exist
+    assert not os.path.exists(repo_playground), f"{repo_playground} already exists"
+
+    # create playground
+    os.makedirs(repo_playground)
+
+    with open(f"{repo_playground}/{temp_name}", "w") as f:
+        f.write(prev_code)
+
+    # lint the code
+    # check for fatal errors
+    fatal = "E9,F821,F823,F831,F406,F407,F701,F702,F704,F706"
+    o = subprocess.run(
+        f"flake8 --select={fatal} --isolated {repo_playground}/{temp_name}",
+        shell=True,
+        capture_output=True,
+    )
+    s = o.stdout.decode("utf-8")
+
+    prev_errors = set()
+    if s != "":
+        for error in s.split(f"{repo_playground}/{temp_name}:")[1:]:
+            num_free_error = ":".join(error.split(":")[2:]).strip()
+            prev_errors.add(num_free_error)
+
+    with open(f"{repo_playground}/{temp_name}", "w") as f:
+        f.write(code)
+
+    o = subprocess.run(
+        f"flake8 --select={fatal} --isolated {repo_playground}/{temp_name}",
+        shell=True,
+        capture_output=True,
+    )
+    s = o.stdout.decode("utf-8")
+
+    # remove playground
+    subprocess.run(f"rm -rf {repo_playground}", shell=True)
+
+    errors = set()
+    if s != "":
+        for error in s.split(f"{repo_playground}/{temp_name}:")[1:]:
+            num_free_error = ":".join(error.split(":")[2:]).strip()
+            errors.add(num_free_error)
+
+    if len(errors - prev_errors) > 0:
+        return False, prev_errors, errors
+
+    return True, set(), set()
+
+
+def fake_git_repo(repo_playground, file_pathes, old_contents, new_contents) -> str:
+    """create a fake git repo to obtain git diff format"""
+
+    if not isinstance(file_pathes, list):
+        # for backwards compatibility
+        file_pathes = [file_pathes]
+        old_contents = [old_contents]
+        new_contents = [new_contents]
+
+    # Generate a temperary folder and add uuid to avoid collision
+    repo_playground = os.path.join(repo_playground, str(uuid.uuid4()))
+
+    # assert playground doesn't exist
+    assert not os.path.exists(repo_playground), f"{repo_playground} already exists"
+
+    # create playground
+    os.makedirs(repo_playground)
+
+    # create a fake git repo
+    subprocess.run(f"cd {repo_playground} && git init", shell=True)
+
+    for file_path, old_content, new_content in zip(
+        file_pathes, old_contents, new_contents
+    ):
+        # create a file
+        subprocess.run(
+            f"mkdir -p {repo_playground}/{os.path.dirname(file_path)}", shell=True
+        )
+
+        with open(f"{repo_playground}/{file_path}", "w") as f:
+            f.write(old_content)
+
+        # add file to git
+        # same message is okay
+        subprocess.run(
+            f"cd {repo_playground} && git add {file_path} && git commit -m 'initial commit'",
+            shell=True,
+        )
+
+    for file_path, old_content, new_content in zip(
+        file_pathes, old_contents, new_contents
+    ):
+        # edit file
+        with open(f"{repo_playground}/{file_path}", "w") as f:
+            f.write(new_content)
+
+    # get git diff
+    o = subprocess.run(
+        f"cd {repo_playground} && git diff .", shell=True, capture_output=True
+    )
+
+    s = o.stdout.decode("utf-8")
+
+    # remove playground
+    subprocess.run(f"rm -rf {repo_playground}", shell=True)
+
+    return s
+
+
+def fake_git_apply(repo_playground, file_path, old_content, patch) -> str:
+    """create a fake git repo to obtain new file content"""
+
+    # Generate a temperary folder and add uuid to avoid collision
+    repo_playground = os.path.join(repo_playground, str(uuid.uuid4()))
+
+    # assert playground doesn't exist
+    assert not os.path.exists(repo_playground), f"{repo_playground} already exists"
+
+    # create playground
+    os.makedirs(repo_playground)
+
+    # create a fake git repo
+    subprocess.run(f"cd {repo_playground} && git init", shell=True)
+
+    # create a file
+    subprocess.run(
+        f"mkdir -p {repo_playground}/{os.path.dirname(file_path)}", shell=True
+    )
+
+    with open(f"{repo_playground}/{file_path}", "w") as f:
+        f.write(old_content)
+
+    # add file to git
+    subprocess.run(
+        f"cd {repo_playground} && git add {file_path} && git commit -m 'initial commit'",
+        shell=True,
+    )
+
+    # apply patch file
+    patch_file = f"{str(uuid.uuid4())}.patch"
+    with open(f"{repo_playground}/{patch_file}", "w") as f:
+        f.write(patch)
+    o = subprocess.run(
+        f"cd {repo_playground} && git apply --whitespace=nowarn {patch_file}",
+        shell=True,
+        capture_output=True,
+    )
+    if o.stderr.decode("utf-8"):
+        print("stderr> ", o.stderr.decode("utf-8"))
+        # TODO: This rarely happen but the patch should be valid, needs to look into it
+
+        with open(f"{repo_playground}/{file_path}", "w") as f:
+            f.write(old_content + "\n")
+
+        o = subprocess.run(
+            f"cd {repo_playground} && git apply --whitespace=nowarn {patch_file}",
+            shell=True,
+            capture_output=True,
+        )
+
+        if o.stderr.decode("utf-8"):
+            print("stderr> ", o.stderr.decode("utf-8"))
+            assert False, "shouldn't happen"
+
+    # get git diff
+    o = subprocess.run(
+        f"cd {repo_playground} && cat {file_path}", shell=True, capture_output=True
+    )
+
+    s = o.stdout.decode("utf-8")
+
+    # remove playground
+    subprocess.run(f"rm -rf {repo_playground}", shell=True)
+
+    return s
+
+
+def fake_git_apply_multiple(repo_playground, file_path_contents, patch) -> dict:
+    """create a fake git repo to obtain new file contents (multiple)"""
+
+    # Generate a temperary folder and add uuid to avoid collision
+    repo_playground = os.path.join(repo_playground, str(uuid.uuid4()))
+
+    # assert playground doesn't exist
+    assert not os.path.exists(repo_playground), f"{repo_playground} already exists"
+
+    # create playground
+    os.makedirs(repo_playground)
+
+    # create a fake git repo
+    subprocess.run(f"cd {repo_playground} && git init", shell=True)
+
+    # create files
+    for file_path, old_content in file_path_contents.items():
+        subprocess.run(
+            f"mkdir -p {repo_playground}/{os.path.dirname(file_path)}", shell=True
+        )
+
+        with open(f"{repo_playground}/{file_path}", "w") as f:
+            f.write(old_content)
+
+        # add file to git
+        subprocess.run(
+            f"cd {repo_playground} && git add {file_path} && git commit -m 'initial commit'",
+            shell=True,
+        )
+
+    # apply patch file
+    patch_file = f"{str(uuid.uuid4())}.patch"
+    with open(f"{repo_playground}/{patch_file}", "w") as f:
+        f.write(patch)
+    o = subprocess.run(
+        f"cd {repo_playground} && git apply --whitespace=nowarn {patch_file}",
+        shell=True,
+        capture_output=True,
+    )
+    if o.stderr.decode("utf-8"):
+        print("stderr> ", o.stderr.decode("utf-8"))
+        # TODO: This rarely happen but the patch should be valid, needs to look into it
+        for file_path, old_content in file_path_contents.items():
+            with open(f"{repo_playground}/{file_path}", "w") as f:
+                f.write(old_content + "\n")
+
+        o = subprocess.run(
+            f"cd {repo_playground} && git apply --whitespace=nowarn {patch_file}",
+            shell=True,
+            capture_output=True,
+        )
+
+        if o.stderr.decode("utf-8"):
+            print("stderr> ", o.stderr.decode("utf-8"))
+            assert False, "shouldn't happen"
+
+    new_file_path_contents = {}
+
+    # get git diff
+    for file_path, old_content in file_path_contents.items():
+        o = subprocess.run(
+            f"cd {repo_playground} && cat {file_path}", shell=True, capture_output=True
+        )
+
+        s = o.stdout.decode("utf-8")
+
+        new_file_path_contents[file_path] = s
+
+    # remove playground
+    subprocess.run(f"rm -rf {repo_playground}", shell=True)
+
+    return new_file_path_contents
+
+
+def get_functions(tree):
+    """Get a set of function and method names from the AST tree."""
+    functions = {}
+
+    class FunctionVisitor(ast.NodeVisitor):
+        def __init__(self):
+            self.parents = []
+
+        def visit(self, node):
+            self.parents.append(node)
+            super().visit(node)
+            self.parents.pop()
+
+        def visit_FunctionDef(self, node):
+            if not any(isinstance(parent, ast.ClassDef) for parent in self.parents):
+                functions[node.name] = ast.unparse(node)
+            self.generic_visit(node)
+
+        def visit_AsyncFunctionDef(self, node):
+            if not any(isinstance(parent, ast.ClassDef) for parent in self.parents):
+                functions[node.name] = ast.unparse(node)
+            self.generic_visit(node)
+
+    class ClassVisitor(ast.NodeVisitor):
+        def visit_ClassDef(self, node):
+            class_name = node.name
+            for body_item in node.body:
+                if isinstance(body_item, ast.FunctionDef) or isinstance(
+                    body_item, ast.AsyncFunctionDef
+                ):
+                    functions[f"{class_name}.{body_item.name}"] = ast.unparse(body_item)
+            self.generic_visit(node)
+
+    FunctionVisitor().visit(tree)
+    ClassVisitor().visit(tree)
+    return functions
+
+
+def is_just_new_function(code1, code2):
+    tree1 = ast.parse(code1)
+    tree2 = ast.parse(code2)
+
+    functions1 = get_functions(tree1)
+    functions2 = get_functions(tree2)
+
+    # The new functions in the second code
+    if len(set(list(functions1.keys())) - set(list(functions2.keys()))) > 0:
+        # removes functions
+        return False
+
+    for func in functions1:
+        if functions1[func] != functions2[func]:
+            # modifies existing functions
+            return False
+
+    if len(set(list(functions2.keys())) - set(list(functions1.keys()))) > 0:
+        return True
+
+    # modifying global stuff is okay, because its actually same as functions almost.
+
+    return False
+
+
+import io
+import re
+import tokenize
+
+
+def remove_comments_and_docstrings(source):
+    io_obj = io.StringIO(source)
+    out = ""
+    prev_toktype = tokenize.INDENT
+    last_lineno = -1
+    last_col = 0
+    for tok in tokenize.generate_tokens(io_obj.readline):
+        token_type = tok[0]
+        token_string = tok[1]
+        start_line, start_col = tok[2]
+        end_line, end_col = tok[3]
+        ltext = tok[4]
+        if start_line > last_lineno:
+            last_col = 0
+        if start_col > last_col:
+            out += " " * (start_col - last_col)
+        if token_type == tokenize.COMMENT:
+            pass
+        elif token_type == tokenize.STRING:
+            if prev_toktype != tokenize.INDENT:
+                if prev_toktype != tokenize.NEWLINE:
+                    if start_col > 0:
+                        out += token_string
+        else:
+            out += token_string
+        prev_toktype = token_type
+        last_col = end_col
+        last_lineno = end_line
+    out = "\n".join(l for l in out.splitlines() if l.strip())
+    return out
+
+
+def normalize_patch(
+    instance_id,
+    patch: str,
+    original_file_content: list,
+    new_file_content: list,
+    edited_files: list,
+) -> str:
+    "Remove edits to trailing spaces and comments in the patch."
+    if not patch.strip():
+        return ""
+
+    normalized_diff = ""
+
+    for o_file_content, n_file_content, edited_file in zip(
+        original_file_content, new_file_content, edited_files
+    ):
+        old_content = o_file_content
+        new_content = n_file_content
+
+        # Normalize file contents
+        def normalize_code(code):
+            try:
+                node = ast.parse(code)
+                return ast.unparse(node)
+            except:
+                return code
+
+        old_content = normalize_code(old_content)
+        new_content = normalize_code(new_content)
+
+        try:
+            remove_docstring_old_content = remove_comments_and_docstrings(old_content)
+            ast.parse(remove_docstring_old_content)  # check
+            remove_docstring_new_content = remove_comments_and_docstrings(new_content)
+            ast.parse(remove_docstring_new_content)  # check
+        except:
+            # when does this exception happen?
+            # when the code has some class or function with empty docstring (thats valid python code)
+            # but removing it is not, to be save we just use the original.
+            remove_docstring_old_content = old_content
+            remove_docstring_new_content = new_content
+
+        diff = fake_git_repo(
+            "playground",
+            edited_file,
+            remove_docstring_old_content,
+            remove_docstring_new_content,
+        )
+
+        if is_just_new_function(
+            remove_docstring_old_content, remove_docstring_new_content
+        ):
+            # modify the diff to ignore context.
+            new_diff = []
+            for line in diff.splitlines():
+                if line.startswith("-") or line.startswith("+"):
+                    new_diff.append(line)
+            diff = "\n".join(new_diff)
+
+        normalized_diff += diff
+
+    # Note that the normalized diff may not be applied to the original file.
+    return normalized_diff
+
+
+def extract_python_blocks(text):
+    # Regular expression pattern to match ```python\n{text}\n```
+    pattern = r"```python\n(.*?)\n```"
+
+    # Use re.findall to find all matches
+    matches = re.findall(pattern, text, re.DOTALL)
+
+    return matches
+
+
+def extract_code_blocks(text):
+    pattern = r"```\n(.*?)\n```"
+    matches = re.findall(pattern, text, re.DOTALL)
+    if len(matches) == 0:
+        if "```" in text:
+            # handle the case where the code block is not complete
+            return [text.split("```", 1)[-1].strip()]
+    return matches
+
+
+def extract_locs_for_files(locs, file_names, keep_old_order=False):
+    if keep_old_order:
+        results = {fn: [] for fn in file_names}
+    else:
+        results = {}  # dict is insertion ordered
+    current_file_name = None
+    for loc in locs:
+        for line in loc.splitlines():
+            stripped = line.strip()
+            if not stripped:
+                continue
+            if _is_source_path(stripped, file_names):
+                current_file_name = stripped
+            elif any(stripped.startswith(w) for w in LOC_PREFIXES):
+                if current_file_name in file_names:
+                    if current_file_name not in results:
+                        results[current_file_name] = []
+                    results[current_file_name].append(stripped)
+
+    for file_name in file_names:
+        if file_name not in results:  # guard for new order case
+            results[file_name] = []
+
+    return {fn: ["\n".join(results[fn])] for fn in results.keys()}
+
+
+def extract_starting_number(subcommand):
+    return int(subcommand.split(",")[0].split("start=")[-1])
+
+
+def extract_ending_number(subcommand):
+    return int(subcommand.split(",")[1].split("end=")[-1])
+
+
+def overlap(subcommand1, subcommand2):
+    start1, end1 = extract_starting_number(subcommand1), extract_ending_number(
+        subcommand1
+    )
+    start2, end2 = extract_starting_number(subcommand2), extract_ending_number(
+        subcommand2
+    )
+    return not (end1 < start2 or end2 < start1)
+
+
+def split_edit_multifile_commands(
+    commands, diff_format=False, str_replace_format=False
+) -> dict[str, str]:
+    """Split commands based on edited files."""
+    file_to_commands = OrderedDict()
+    if str_replace_format:
+        for command in commands:
+            file_name = None
+            for json_message in command:
+                if json_message["type"] == "tool_use":
+                    str_replace_command = json_message["input"]
+
+                    if "command" not in str_replace_command:
+                        str_replace_command["command"] = "str_replace"
+
+                    if "path" not in str_replace_command:
+                        continue
+
+                    if "command" not in str_replace_command:
+                        continue
+
+                    if str_replace_command["command"] == "str_replace":
+                        if "old_str" not in str_replace_command:
+                            continue
+
+                        if "new_str" not in str_replace_command:
+                            # add empty string
+                            str_replace_command["new_str"] = ""
+
+                    if str_replace_command["command"] == "insert":
+                        if (
+                            "insert_line" not in str_replace_command
+                            or "new_str" not in str_replace_command
+                        ):
+                            continue
+
+                    file_name = "'" + str_replace_command["path"] + "'"
+                    # deduplicate
+                    if (
+                        file_name not in file_to_commands
+                        or str_replace_command not in file_to_commands[file_name]
+                    ):
+                        file_to_commands.setdefault(file_name, []).append(
+                            str_replace_command
+                        )
+
+    elif diff_format:
+        for command in commands:
+            file_name = None
+            for subcommand in command.split(">>>>>>> REPLACE")[:-1]:
+                subcommand = subcommand.strip()
+                if "<<<<<<< SEARCH" in subcommand:
+                    fn = subcommand.split("<<<<<<< SEARCH")[0].lstrip("#").strip()
+                    if fn:
+                        file_name = "'" + fn + "'"
+
+                if len(subcommand.split("<<<<<<< SEARCH")) != 2:
+                    continue
+                converted_command = (
+                    "<<<<<<< SEARCH"
+                    + subcommand.split("<<<<<<< SEARCH")[1]
+                    + "\n"
+                    + ">>>>>>> REPLACE"
+                )
+                # deduplicate
+                if (
+                    file_name not in file_to_commands
+                    or converted_command not in file_to_commands[file_name]
+                ):
+                    file_to_commands.setdefault(file_name, []).append(converted_command)
+
+    else:
+        for command in commands:
+            for subcommand in command.split("edit_file(")[1:]:
+                file_name, start, end, content = subcommand.split(",", 3)
+                converted_command = "edit_file(" + ",".join([start, end, content])
+                # deduplicate
+                if (
+                    file_name not in file_to_commands
+                    or converted_command not in file_to_commands[file_name]
+                ):
+                    file_to_commands.setdefault(file_name, []).append(converted_command)
+
+    return file_to_commands
+
+
+def parse_str_replace_edit_commands(
+    commands, content, file_loc_intervals: list[tuple[int, int]]
+):
+    """
+    Original implementation: https://github.com/anthropics/anthropic-quickstarts/blob/main/computer-use-demo/computer_use_demo/tools/edit.py
+    """
+    # let's first make sure the intervals are sorted
+    file_loc_intervals.sort()
+    replaced = False
+    # apply the edits from the end of file to the beginning of file
+    # this is to make sure context is correct
+    for interval in file_loc_intervals[::-1]:
+        start, end = interval
+        start = max(start - 1, 0)
+        # intervals are 1-indexed
+
+        context_segment = "\n".join(content.splitlines()[start:end])
+        context_segment = "\n" + context_segment + "\n"
+
+        # since we want to replace the original context, let's first check for all edits.
+        can_apply = []
+        for subcommand in commands:
+
+            if subcommand["command"] == "str_replace":
+                original, replace = subcommand["old_str"], subcommand["new_str"]
+
+                if original in context_segment:
+                    can_apply.append(subcommand)
+
+            elif subcommand["command"] == "insert":
+                insert_line = subcommand["insert_line"]
+                # TODO check this
+                if insert_line > start and insert_line <= end:
+                    can_apply.append(subcommand)
+
+        # apply edits backwards
+        for subcommand in can_apply[::-1]:
+
+            if subcommand["command"] == "str_replace":
+                original, replace = subcommand["old_str"], subcommand["new_str"]
+
+                if (
+                    original in context_segment
+                ):  # This may not be true after some previously applied edits
+                    context_segment = context_segment.replace(original, replace)
+                    replaced = True
+
+            elif subcommand["command"] == "insert":
+                insert_line = subcommand["insert_line"]
+                replace = subcommand["new_str"]
+                # TODO check this
+                if insert_line > start and insert_line <= end:
+
+                    if insert_line != start - 1:
+                        replace = "\n" + replace
+                    if insert_line != end:
+                        replace = replace + "\n"
+                    context_segment = (
+                        "\n".join(
+                            context_segment.splitlines()[: insert_line - start + 1]
+                        )
+                        + replace
+                        + "\n".join(
+                            context_segment.splitlines()[insert_line - start + 1 :]
+                        )
+                    )
+                    context_segment = context_segment + "\n"
+                    replaced = True
+
+        # reassembly
+        content = (
+            "\n".join(content.splitlines()[:start])
+            + context_segment
+            + "\n".join(content.splitlines()[end:])
+        )
+
+    if not replaced:
+        print("not replaced")
+
+    return content
+
+
+def parse_diff_edit_commands(
+    commands, content, file_loc_intervals: list[tuple[int, int]]
+):
+    def parse_for_threedots(original, replace, file_loc_intervals, content):
+        # if dot dot dot in replace, its always safe to remove it
+        if replace.startswith("...\n") and len(replace) > 4:
+            # im parsing this first because its used later on
+            replace = replace[4:]
+
+        # just dot dot dot, then need to do something special
+        if original == "...":
+            if not replace[0].isspace():
+                # this is okay
+                # find a suitable original string to replace
+                for interval in file_loc_intervals:
+                    start, end = interval
+                    start = max(start - 1, 0)
+                    context_segment = "\n".join(content.splitlines()[start:end])
+
+                    for line in context_segment.splitlines():
+                        if len(line) > 0 and not line[0].isspace():
+                            if content.count(line) == 1:
+                                original = line
+                                # keep the line
+                                replace = replace + "\n\n" + line
+                                break
+
+                    if original != "...":
+                        break
+
+                if original == "...":
+                    print("cannot find suitable location")
+
+        # dot dot dot with something else in original, then its safe to replace
+        if original.startswith("...\n") and len(original) > 4:
+            # remove dot dot dot from original
+            original = original[4:]
+
+        return original, replace
+
+    if len(file_loc_intervals) == 0:
+        if original in content:
+            content = content.replace(original, replace)
+            replaced = True
+        else:
+            print("not replaced")
+        return content
+    # let's first make sure the intervals are sorted
+    file_loc_intervals.sort()
+    replaced = False
+    # apply the edits from the end of file to the beginning of file
+    # this is to make sure context is correct
+    for interval in file_loc_intervals[::-1]:
+        start, end = interval
+        start = max(start - 1, 0)
+        context_segment = "\n".join(content.splitlines()[start:end])
+        context_segment = "\n" + context_segment + "\n"
+
+        # since we want to replace the original context, let's first check for all edits.
+        can_apply = []
+        for subcommand in commands:
+            if not subcommand.startswith("<<<<<<< SEARCH") and subcommand.endswith(
+                ">>>>>>> REPLACE"
+            ):
+                continue
+
+            subcommand = "\n".join(subcommand.splitlines()[1:-1])
+            if len(subcommand.split("\n=======\n")) != 2:
+                continue
+
+            original, replace = subcommand.split("\n=======\n")
+
+            original, replace = parse_for_threedots(
+                original, replace, file_loc_intervals, content
+            )
+
+            original = "\n" + original + "\n"
+            replace = "\n" + replace + "\n"
+
+            if original in context_segment:
+                can_apply.append(subcommand)
+
+        # apply edits backwards
+        for subcommand in can_apply[::-1]:
+            original, replace = subcommand.split("\n=======\n")
+
+            original, replace = parse_for_threedots(
+                original, replace, file_loc_intervals, content
+            )
+
+            original = "\n" + original + "\n"
+            replace = "\n" + replace + "\n"
+            if (
+                original in context_segment
+            ):  # This may not be true after some previously applied edits
+                context_segment = context_segment.replace(original, replace)
+                replaced = True
+        # reassembly
+        content = (
+            "\n".join(content.splitlines()[:start])
+            + context_segment
+            + "\n".join(content.splitlines()[end:])
+        )
+
+    if not replaced:
+        print("not replaced")
+
+    return content
+
+
+def parse_edit_commands(commands, content):
+    content_lines = content.splitlines()
+    map_content_lines_to_line_num = [i for i in range(0, len(content_lines) + 1)]
+
+    # Make a list of the subcommands
+    subcommands = []
+
+    for command in commands:
+        for subcommand in command.split("edit_file(")[1:]:
+            subcommands.append(subcommand)
+
+    # Remove duplicates while preserving order
+    seen = set()
+    unique_subcommands = []
+    for subcommand in subcommands:
+        if subcommand not in seen:
+            unique_subcommands.append(subcommand)
+            seen.add(subcommand)
+
+    # Sort the unique subcommands by the starting number in reverse order
+    unique_sorted_subcommands = sorted(
+        unique_subcommands, key=extract_starting_number, reverse=True
+    )
+
+    for subcommand in unique_sorted_subcommands:
+        command_start = int(subcommand.split(",")[0].split("start=")[-1])
+        command_end = int(subcommand.split(",")[1].split("end=")[-1])
+
+        start = map_content_lines_to_line_num.index(command_start)
+        end = map_content_lines_to_line_num.index(command_end)
+
+        try:
+            changed_content = eval(
+                ")".join(",".join(subcommand.split(",")[2:]).split(")")[:-1])
+            )
+            # small thing to ensure right white space indent
+            if (
+                start == end
+                and len(changed_content.splitlines()) == 1
+                and (len(changed_content) - len(changed_content.lstrip())) == 0
+            ):
+                indent_length = len(content_lines[start - 1]) - len(
+                    content_lines[start - 1].lstrip()
+                )
+                changed_content = " " * indent_length + changed_content.lstrip()
+
+        # catch syntax error
+        except:
+            # try to fix, specially for case where there are """ or ''' in the string, that cannot be
+            # easily evaluated.
+            eval_str = ")".join(
+                ",".join(subcommand.split(",")[2:]).split(")")[:-1]
+            ).strip()
+
+            if eval_str.startswith("content="):
+                eval_str = eval_str[8:]
+
+            if eval_str.startswith('"""') or eval_str.startswith("'''"):
+                eval_str = eval_str[3:-3]
+            if eval_str.startswith('"') or eval_str.startswith("'"):
+                eval_str = eval_str[1:-1]
+
+            changed_content = eval_str
+
+        content_lines[start - 1 : end] = changed_content.splitlines()
+
+    content = "\n".join(content_lines)
+
+    return content
+
+
+def test_parse_str_replace():
+
+    content = """A
+B
+C
+D
+E
+F
+""".strip()
+
+    from agentless.util.preprocess_data import line_wrap_content
+
+    shown_content = line_wrap_content(content, context_intervals=[(3, 5)])
+    print(shown_content)
+
+    commands = [
+        {"command": "insert", "path": "test", "insert_line": 1, "new_str": "test_str"}
+    ]
+    new_content = parse_str_replace_edit_commands(
+        commands, content, file_loc_intervals=[(1, 5)]
+    )
+    print(new_content)
+
+
+def test_parse():
+    raw_output = """
+```python
+edit_file(1, 1, "import os")
+```
+"""
+
+    content = """
+import sys
+""".strip()
+
+    commands = extract_python_blocks(raw_output)
+
+    content = parse_edit_commands(commands, content)
+
+    assert content == "import os", content
+
+    raw_output = """
+```python
+edit_file(1, 1, '''import os\nimport sys''')
+```
+"""
+
+    content = """
+import sys
+""".strip()
+
+    commands = extract_python_blocks(raw_output)
+
+    content = parse_edit_commands(commands, content)
+
+    assert content == "import os\nimport sys", content
+
+    raw_output = """
+```python
+edit_file(1, 1, '''import os''')
+edit_file(1, 1, '''import sys''')
+```
+"""
+
+    content = """
+import sys
+""".strip()
+
+    commands = extract_python_blocks(raw_output)
+
+    content = parse_edit_commands(commands, content)
+
+    assert content == "import sys", content
+
+    content = """
+test
+testing
+""".strip()
+    raw_output = """
+```python
+edit_file(1, 1, "testing\ntesting2")
+edit_file(2, 2, "testing3")
+```
+"""
+    content = parse_edit_commands(extract_python_blocks(raw_output), content)
+
+    assert content == "testing\ntesting2\ntesting3", content
+
+    content = """
+test
+testing
+testinging
+""".strip()
+
+    raw_output = """
+```python
+edit_file(1, 2, "testing")
+edit_file(3, 3, "testing3")
+```
+"""
+    content = parse_edit_commands(extract_python_blocks(raw_output), content)
+
+    assert content == "testing\ntesting3", content
+
+    content = """
+test
+testing
+testinging
+test
+testing
+""".strip()
+
+    raw_output = """
+```python
+edit_file(1, 2, "testing")
+edit_file(3, 3, "testing3")
+edit_file(4, 4, "testing\ntesting2")
+edit_file(5, 5, "testing3")
+```
+"""
+
+    edited_content = """
+testing
+testing3
+testing
+testing2
+testing3
+""".strip()
+    content = parse_edit_commands(extract_python_blocks(raw_output), content)
+
+    assert content == edited_content, content
+
+    # Test for if command is present twice in the output (adapted from real output)
+    content = """
+test
+testing
+testinging
+test
+testing
+""".strip()
+
+    raw_output = (
+        """
+"To fix the issue where `viewcode`
+1. Add a condition
+
+```python
+edit_file(4, 4, """
+        """
+test4
+"""
+        """)
+```
+
+2. Ensure that the `doctree_read`
+
+```python
+edit_file(2, 3, """
+        """
+test-2-3
+"""
+        """)
+```
+
+Here is the complete set of commands to address the issue:
+
+```python
+edit_file(4, 4, """
+        """
+test4
+"""
+        """)
+```
+
+```python
+edit_file(2, 3, """
+        """
+test-2-3
+"""
+        """)
+```
+"""
+    )
+    content = parse_edit_commands(extract_python_blocks(raw_output), content)
+
+    revised_content = """
+test
+test-2-3
+test4
+testing
+""".strip()
+
+    assert content == revised_content, content
+
+    raw_output = """
+```
+django/db/migrations/optimizer.py
+function: MigrationOptimizer.optimize_inner
+
+django/db/migrations/operations/fields.py
+function: AlterField.reduce
+```
+"""
+    files = [
+        "django/db/migrations/optimizer.py",
+        "django/db/migrations/operations/fields.py",
+        "django/db/migrations/operations/models.py",
+    ]
+    extracted_locs = extract_locs_for_files([raw_output], files)
+    print(extracted_locs)
+    assert extracted_locs == [
+        ["function: MigrationOptimizer.optimize_inner"],
+        ["function: AlterField.reduce"],
+        [""],
+    ]
+
+    raw_output = """
+```python
+edit_file(start=1, end=1, content="testing not")
+```
+"""
+
+    content = """
+testing
+""".strip()
+
+    edited_content = """
+testing not
+""".strip()
+
+    content = parse_edit_commands(extract_python_blocks(raw_output), content)
+    assert content == edited_content, edited_content
+
+
+if __name__ == "__main__":
+    # test_parse()
+
+    # Example Usage
+    code1 = """
+class MyClass:
+    def existing_method(self):
+        pass
+"""
+
+    code2 = """
+class MyClass:
+    def existing_method(self):
+        pass
+
+    async def new_method(self):
+        pass
+"""
+
+    print(is_just_new_function(code1, code2))  # Output: True

Repos/HWE/agents/Agentless/agentless/util/preprocess_data.py

@@ -0,0 +1,868 @@
+import json
+import os
+
+from get_repo_structure.get_repo_structure import get_project_structure_from_scratch
+
+try:
+    from get_repo_structure.get_repo_structure import parse_verilog_file as parse_source_file
+except ImportError:
+    from get_repo_structure.get_repo_structure import parse_python_file as parse_source_file
+
+SOURCE_EXTENSIONS = {".v", ".sv", ".vh", ".svh", ".py"}
+MODULE_PREFIXES = (
+    "module:",
+    "interface:",
+    "package:",
+    "program:",
+    "class:",
+    "checker:",
+    "config:",
+    "primitive:",
+    "udp:",
+)
+FUNCTION_PREFIXES = ("function:", "task:", "method:")
+
+
+def _get_global_vars(file_content: str) -> dict:
+    try:
+        from agentless.util.parse_global_var import parse_global_var_from_code
+    except Exception:
+        return {}
+    global_vars = parse_global_var_from_code(file_content)
+    return global_vars if isinstance(global_vars, dict) else {}
+
+def line_wrap_content(
+    content: str,
+    context_intervals=None,
+    add_space=False,
+    no_line_number=False,
+    sticky_scroll=False,
+):
+    """add n| to each line, where n increases"""
+
+    def is_scope(line):
+        # TODO: this might not be precise, can improve with syntax parsing
+        stripped = line.strip()
+        return stripped.startswith("def ") or stripped.startswith("class ") or any(
+            stripped.startswith(token)
+            for token in (
+                "module ",
+                "interface ",
+                "package ",
+                "program ",
+                "class ",
+                "function ",
+                "task ",
+            )
+        )
+
+    lines = content.split("\n")
+    new_lines = []
+    if context_intervals is None or context_intervals == []:
+        context_intervals = [(0, len(lines))]
+
+    prev_scopes = []
+    line_format = "{line}"
+    if not no_line_number:
+        line_format = (
+            "{line_number}|{line}" if not add_space else "{line_number}| {line} "
+        )
+    for interval in context_intervals:
+        min_line, max_line = interval
+
+        if min_line != 0:
+            new_lines.append("...")
+
+        scopes = []
+        for i, line in enumerate(lines):
+            if sticky_scroll:
+                # add current line to scope if necessary
+                if is_scope(line):
+                    indent_level = len(line) - len(line.lstrip())
+                    while scopes and scopes[-1]["indent_level"] >= indent_level:
+                        scopes.pop()
+                    scopes.append(
+                        {"line": line, "line_number": i, "indent_level": indent_level}
+                    )
+
+            if min_line != -1 and i < min_line - 1:
+                continue
+            if sticky_scroll and i == min_line - 1:
+                # add scope lines
+                last_scope_line = None
+                for j, scope_line in enumerate(scopes):
+                    # don't repeat previous scopes
+                    if (
+                        len(prev_scopes) > j
+                        and prev_scopes[j]["line_number"] == scope_line["line_number"]
+                    ):
+                        continue
+                    # don't repeat current line
+                    if i == scope_line["line_number"]:
+                        continue
+                    new_lines.append(
+                        line_format.format(
+                            line_number=scope_line["line_number"] + 1,
+                            line=scope_line["line"],
+                        )
+                    )
+                    last_scope_line = scope_line["line_number"]
+                if last_scope_line is not None and last_scope_line < i - 1:
+                    new_lines.append("...")
+
+            new_lines.append(line_format.format(line_number=i + 1, line=line))
+            if max_line != -1 and i >= max_line - 1:
+                break
+        prev_scopes = scopes
+
+    if max_line != len(lines):
+        new_lines.append("...")
+
+    return "\n".join(new_lines)
+
+
+def merge_intervals(intervals):
+    # intervals inclusive
+    if not intervals:
+        return []
+
+    # Sort the intervals based on the starting value of each tuple
+    intervals.sort(key=lambda interval: interval[0])
+
+    merged_intervals = [intervals[0]]
+
+    for current in intervals[1:]:
+        last = merged_intervals[-1]
+
+        # Check if there is overlap
+        if current[0] <= last[1]:
+            # If there is overlap, merge the intervals
+            merged_intervals[-1] = (last[0], max(last[1], current[1]))
+        else:
+            # If there is no overlap, just add the current interval to the result list
+            merged_intervals.append(current)
+
+    return merged_intervals
+
+
+def transfer_arb_locs_to_locs(
+    locs,
+    structure,
+    pred_file,
+    context_window=10,
+    loc_interval=False,
+    fine_grain_only=False,
+    remove_line=False,
+    file_content="",
+    verbose=False,
+) -> tuple[list, list]:
+    if structure is None:
+        class_info, function_names, file_lines = parse_source_file("", file_content)
+        structure = {}
+        structure[pred_file] = {
+            "classes": class_info,
+            "functions": function_names,
+            "text": file_lines,
+        }
+
+    files, classes, functions = get_full_file_paths_and_classes_and_functions(structure)
+
+    line_loc = []
+    if isinstance(locs, str):
+        # if its a single loc
+        locs = [locs]
+    # TODO: parse it in advance
+    global_vars = _get_global_vars(file_content)
+    unrecognized_locs = []
+
+    for model_pred_locs in locs:
+        current_class_name = ""
+        for loc in model_pred_locs.splitlines():
+            # handle cases like "class: MyClass.my_method"
+            module_prefix = next(
+                (prefix for prefix in MODULE_PREFIXES if loc.startswith(prefix)), None
+            )
+            if module_prefix and "." not in loc:
+                loc = loc[len(module_prefix) :].strip()
+                relevant_class = [
+                    clazz
+                    for clazz in classes
+                    if clazz["file"] == pred_file and clazz["name"] == loc
+                ]
+
+                if len(relevant_class) == 0:
+                    unrecognized_locs.append(loc)
+                else:
+                    line_loc.append(
+                        (relevant_class[0]["start_line"], relevant_class[0]["end_line"])
+                    )
+                    current_class_name = loc
+
+            elif loc.startswith(FUNCTION_PREFIXES) or "." in loc:
+                full_loc = loc
+                loc = loc.split(":", 1)[-1].strip()
+
+                if "." in loc:
+                    # assume its a method within a class
+                    method_name = loc.split(".")[1]
+                    class_name = loc.split(".")[0]
+
+                    relevant_class = [
+                        clazz
+                        for clazz in classes
+                        if clazz["file"] == pred_file and clazz["name"] == class_name
+                    ]
+                    if len(relevant_class) == 0:
+                        unrecognized_locs.append(loc)
+                    else:
+                        relevant_method = [
+                            method
+                            for method in relevant_class[0]["methods"]
+                            if method["name"] == method_name
+                        ]
+                        if len(relevant_method) == 0:
+                            unrecognized_locs.append(loc)
+                        else:
+                            line_loc.append(
+                                (
+                                    relevant_method[0]["start_line"],
+                                    relevant_method[0]["end_line"],
+                                )
+                            )
+
+                else:
+                    relevant_function = [
+                        function
+                        for function in functions
+                        if function["file"] == pred_file and function["name"] == loc
+                    ]
+                    if len(relevant_function) == 0:
+                        if current_class_name != "":
+                            # check if its a method
+                            relevant_class = [
+                                clazz
+                                for clazz in classes
+                                if clazz["file"] == pred_file
+                                and clazz["name"] == current_class_name
+                            ]
+                            relevant_method = [
+                                method
+                                for method in relevant_class[0]["methods"]
+                                if method["name"] == loc
+                            ]
+                            if len(relevant_method) == 0:
+                                unrecognized_locs.append(loc)
+                            else:
+                                line_loc.append(
+                                    (
+                                        relevant_method[0]["start_line"],
+                                        relevant_method[0]["end_line"],
+                                    )
+                                )
+                        else:
+                            # look for it in any class
+                            relevant_method = []
+                            for clazz in classes:
+                                if clazz["file"] == pred_file:
+                                    relevant_method.extend(
+                                        [
+                                            method
+                                            for method in clazz["methods"]
+                                            if method["name"] == loc
+                                        ]
+                                    )
+
+                            if len(relevant_method) == 1:
+                                line_loc.append(
+                                    (
+                                        relevant_method[0]["start_line"],
+                                        relevant_method[0]["end_line"],
+                                    )
+                                )
+                    else:
+                        line_loc.append(
+                            (
+                                relevant_function[0]["start_line"],
+                                relevant_function[0]["end_line"],
+                            )
+                        )
+            elif loc.startswith("line: "):
+                if remove_line:
+                    # TODO: can recover the corresponding function instead of throwing it away
+                    continue
+                loc = loc[len("line: ") :].strip().split()[0]
+                try:
+                    # line_loc.append(int(loc))
+                    line_loc.append((int(loc), int(loc)))
+                except:
+                    continue
+            elif loc.startswith("variable:"):
+                vars = loc[len("variable:") :].strip().split()
+                for v in vars:
+                    if v in global_vars:
+                        line_loc.append(
+                            (global_vars[v]["start_line"], global_vars[v]["end_line"])
+                        )
+            else:
+                if loc.strip():
+                    unrecognized_locs.append(loc)
+                # assert False
+
+    # Fine-grained-only loc: Remove intervals that are supersets of another.
+    if fine_grain_only:
+        filtered_line_loc = []
+        for st, en in line_loc:
+            if filtered_line_loc:
+                last_st, last_en = filtered_line_loc[-1]
+                # If the current interval is a more fine-grained loc, remove the superset.
+                if last_st <= st and en <= last_en:
+                    filtered_line_loc.pop()
+            filtered_line_loc.append((st, en))
+        line_loc = filtered_line_loc
+
+    # compute max min
+    # TODO: think of strategies to do bunched up lines
+    # TODO: e.g., we can have multiple code segments (right now, its just one)
+
+    for file_content in files:
+        if file_content[0] == pred_file:
+            content = file_content[1]
+            break
+
+    if len(line_loc) == 0:
+        return [], []
+
+    # max_line = min(max(line_loc) + context_window, len(content))
+    # min_line = max(min(line_loc) - context_window, 0)
+    #
+    # return line_loc, max_line, min_line
+
+    if verbose:
+        print("Unrecognized locs:")
+        for loc in unrecognized_locs:
+            print(loc)
+
+    # compute overlapping locations instead
+    if loc_interval:
+        contextual_line_loc = []
+        for loc in line_loc:
+            # Clip the context window to the beginning and end of the file
+            max_line = max(min(loc[1] + context_window, len(content)), 0)
+            min_line = min(max(loc[0] - context_window, 0), len(content))
+            contextual_line_loc.append((min_line, max_line))
+
+        return line_loc, merge_intervals(contextual_line_loc)
+    else:
+        # defaulting to max min
+        max_line = min(max([loc[1] for loc in line_loc]) + context_window, len(content))
+        min_line = max(min([loc[0] for loc in line_loc]) - context_window, 0)
+
+        return line_loc, [(min_line, max_line)]
+
+
+def check_contains_valid_loc(file_to_locs, structure):
+    """checks if the llm generated locations have at least one location valid"""
+
+    file_contents = get_repo_files(structure, list(file_to_locs.keys()))
+
+    for pred_file, locs in file_to_locs.items():
+        line_locs, _ = transfer_arb_locs_to_locs(
+            locs,
+            structure,
+            pred_file,
+            0,  # these parameters do not matter for checking purposes
+            True,  # these parameters do not matter for checking purposes
+            False,  # these parameters do not matter for checking purposes
+            file_content=file_contents[pred_file] if pred_file in file_contents else "",
+        )
+
+        if len(line_locs) > 0:
+            return True
+
+    return False
+
+
+def compile_gt_locations(gt_location: dict) -> tuple[list, set, set, set]:
+    """mostly serves a way to check what are the gt locations in gt patch"""
+    edits = gt_location["edits"]
+
+    lines, classes, methods, functions = [], set(), set(), set()
+
+    adds = set()
+
+    for edit in edits:
+        for clazz in edit["class_names"]:
+            classes.add(clazz)
+
+        for method in edit["method_names"]:
+            methods.add(method)
+
+        for function in edit["function_names"]:
+            functions.add(function)
+
+        if edit["type"] == "add":
+            adds.add(edit["line"])
+        else:
+            lines.append(edit["line"])
+
+    # handle the added lines
+    add_intervals = [(i, i + 1) for i in adds]
+    add_intervals = merge_intervals(add_intervals)
+    for st, en in add_intervals:
+        lines.append(st)
+    lines = list(set(lines))
+
+    # sort the lines
+    lines = sorted(lines)
+
+    return lines, classes, methods, functions
+
+
+def show_project_structure(structure, spacing=0) -> str:
+    """pprint the project structure"""
+
+    pp_string = ""
+
+    for key, value in structure.items():
+        if "." in key:
+            _, ext = os.path.splitext(key)
+            if ext.lower() not in SOURCE_EXTENSIONS:
+                continue  # skip non-source files
+        if "." in key:
+            pp_string += " " * spacing + str(key) + "\n"
+        else:
+            pp_string += " " * spacing + str(key) + "/" + "\n"
+        if "classes" not in value:
+            pp_string += show_project_structure(value, spacing + 4)
+
+    return pp_string
+
+
+def filter_out_test_files(structure):
+    """filter out test files from the project structure"""
+    for key, value in list(structure.items()):
+        if key.startswith("test"):
+            del structure[key]
+        elif isinstance(value, dict):
+            filter_out_test_files(value)
+
+
+def filter_none_python(structure):
+    for key, value in list(structure.items()):
+        if (
+            not "functions" in value.keys()
+            and not "classes" in value.keys()
+            and not "text" in value.keys()
+        ) or not len(value.keys()) == 3:
+            filter_none_python(value)
+
+            if structure[key] == {}:
+                del structure[key]
+        else:
+            _, ext = os.path.splitext(key)
+            if ext.lower() not in SOURCE_EXTENSIONS:
+                del structure[key]
+
+
+def filter_non_source(structure):
+    filter_none_python(structure)
+
+
+def filter_proposed_files(proposed_files, repo_structure):
+    """
+    Filter proposed files against a given repository structure.
+
+    Arguments:
+    proposed_files -- list of proposed files with instance IDs
+    repo_structure -- list of repository structures with instance IDs
+
+    Returns:
+    A list of dictionaries with instance IDs and valid files matching the repository structure.
+    """
+    instance_to_files = {
+        entry["instance_id"]: entry["files"] for entry in proposed_files
+    }
+    instance_to_structure = {
+        entry["instance_id"]: entry["structure"] for entry in repo_structure
+    }
+    filtered_files = []
+    for instance_id, files in instance_to_files.items():
+        if instance_id in instance_to_structure:
+            repo_files, _, _ = get_full_file_paths_and_classes_and_functions(
+                instance_to_structure[instance_id]
+            )
+            repo_files_set = set(repo_files)
+            valid_files = []
+            for repo_file in repo_files_set:
+                for proposed_file in files:
+                    if proposed_file == repo_file.split("/")[-1]:
+                        valid_files.append(repo_file)
+            if valid_files:
+                filtered_files.append(
+                    {"instance_id": instance_id, "files": valid_files}
+                )
+    return filtered_files
+
+
+def filter_proposed_classes(proposed_classes, repo_structure):
+    """
+    Filter proposed classes against a given repository structure.
+
+    Arguments:
+    proposed_classes -- list of proposed classes with instance IDs
+    repo_structure -- list of repository structures with instance IDs
+
+    Returns:
+    A list of dictionaries with instance IDs and valid classes matching the repository structure.
+    """
+    instance_to_classes = {
+        entry["instance_id"]: entry["classes"] for entry in proposed_classes
+    }
+    instance_to_structure = {
+        entry["instance_id"]: entry["structure"] for entry in repo_structure
+    }
+    filtered_classes = []
+    for instance_id, classes in instance_to_classes.items():
+        if instance_id in instance_to_structure:
+            _, repo_classes, _ = get_full_file_paths_and_classes_and_functions(
+                instance_to_structure[instance_id]
+            )
+            repo_classes_set = {clazz["name"]: clazz["file"] for clazz in repo_classes}
+            valid_classes = []
+            for proposed_class in classes:
+                if proposed_class in repo_classes_set:
+                    valid_classes.append(
+                        {
+                            "name": proposed_class,
+                            "file": repo_classes_set[proposed_class],
+                        }
+                    )
+            if valid_classes:
+                filtered_classes.append(
+                    {"instance_id": instance_id, "classes": valid_classes}
+                )
+    return filtered_classes
+
+
+def filter_proposed_methods(proposed_methods, repo_structure):
+    """
+    Filter proposed methods against a given repository structure.
+
+    Arguments:
+    proposed_methods -- list of proposed methods with instance IDs
+    repo_structure -- list of repository structures with instance IDs
+
+    Returns:
+    A list of dictionaries with instance IDs and valid methods matching the repository structure.
+    """
+    instance_to_methods = {
+        entry["instance_id"]: entry["methods"] for entry in proposed_methods
+    }
+    instance_to_structure = {
+        entry["instance_id"]: entry["structure"] for entry in repo_structure
+    }
+    filtered_methods = []
+    for instance_id, methods in instance_to_methods.items():
+        if instance_id in instance_to_structure:
+            _, repo_classes, _ = get_full_file_paths_and_classes_and_functions(
+                instance_to_structure[instance_id]
+            )
+            valid_methods = []
+            for repo_class in repo_classes:
+                for method in methods:
+                    if method in repo_class["methods"]:
+                        valid_methods.append(
+                            {
+                                "class": repo_class["name"],
+                                "method": method,
+                                "file": repo_class["file"],
+                            }
+                        )
+            if valid_methods:
+                filtered_methods.append(
+                    {"instance_id": instance_id, "methods": valid_methods}
+                )
+    return filtered_methods
+
+
+def filter_proposed_functions(proposed_functions, repo_structure):
+    """
+    Filter proposed functions against a given repository structure.
+
+    Arguments:
+    proposed_functions -- list of proposed functions with instance IDs
+    repo_structure -- list of repository structures with instance IDs
+
+    Returns:
+    A list of dictionaries with instance IDs and valid functions matching the repository structure.
+    """
+    instance_to_functions = {
+        entry["instance_id"]: entry["functions"] for entry in proposed_functions
+    }
+    instance_to_structure = {
+        entry["instance_id"]: entry["structure"] for entry in repo_structure
+    }
+    filtered_functions = []
+    for instance_id, functions in instance_to_functions.items():
+        if instance_id in instance_to_structure:
+            _, _, repo_functions = get_full_file_paths_and_classes_and_functions(
+                instance_to_structure[instance_id]
+            )
+            valid_functions = []
+            for repo_function in repo_functions:
+                for function in functions:
+                    if isinstance(
+                        repo_function["name"], dict
+                    ):  # Why are there cases where this is not a dict?
+                        if function == repo_function["name"].get("name", []):
+                            valid_functions.append(
+                                {"function": function, "file": repo_function["file"]}
+                            )
+            if valid_functions:
+                filtered_functions.append(
+                    {"instance_id": instance_id, "functions": valid_functions}
+                )
+    return filtered_functions
+
+
+def get_full_file_paths_and_classes_and_functions(structure, current_path=""):
+    """
+    Recursively retrieve all file paths, classes, and functions within a directory structure.
+
+    Arguments:
+    structure -- a dictionary representing the directory structure
+    current_path -- the path accumulated so far, used during recursion (default="")
+
+    Returns:
+    A tuple containing:
+    - files: list of full file paths
+    - classes: list of class details with file paths
+    - functions: list of function details with file paths
+    """
+    files = []
+    classes = []
+    functions = []
+    for name, content in structure.items():
+        if isinstance(content, dict):
+            if (
+                not "functions" in content.keys()
+                and not "classes" in content.keys()
+                and not "text" in content.keys()
+            ) or not len(content.keys()) == 3:
+                # or guards against case where functions and classes are somehow part of the structure.
+                next_path = f"{current_path}/{name}" if current_path else name
+                (
+                    sub_files,
+                    sub_classes,
+                    sub_functions,
+                ) = get_full_file_paths_and_classes_and_functions(content, next_path)
+                files.extend(sub_files)
+                classes.extend(sub_classes)
+                functions.extend(sub_functions)
+            else:
+                next_path = f"{current_path}/{name}" if current_path else name
+                files.append((next_path, content["text"]))
+                if "classes" in content:
+                    for clazz in content["classes"]:
+                        classes.append(
+                            {
+                                "file": next_path,
+                                "name": clazz["name"],
+                                "start_line": clazz["start_line"],
+                                "end_line": clazz["end_line"],
+                                "methods": [
+                                    {
+                                        "name": method["name"],
+                                        "start_line": method["start_line"],
+                                        "end_line": method["end_line"],
+                                    }
+                                    for method in clazz.get("methods", [])
+                                ],
+                            }
+                        )
+                if "functions" in content:
+                    for function in content["functions"]:
+                        function["file"] = next_path
+                        functions.append(function)
+        else:
+            next_path = f"{current_path}/{name}" if current_path else name
+            files.append(next_path)
+    return files, classes, functions
+
+
+PROJECT_FILE_LOC = os.environ.get("PROJECT_FILE_LOC", None)
+
+
+def get_repo_structure(instance_id: str, repo_name, base_commit, playground):
+
+    if PROJECT_FILE_LOC is not None:
+        with open(PROJECT_FILE_LOC + "/" + instance_id + ".json") as f:
+            d = json.load(f)
+        repo_structure = d["structure"]
+    else:
+        d = get_project_structure_from_scratch(
+            repo_name, base_commit, instance_id, playground
+        )
+        repo_structure = d["structure"]
+
+    return repo_structure
+
+
+def get_repo_files(structure, filepaths: list[str]):
+    files, classes, functions = get_full_file_paths_and_classes_and_functions(structure)
+    file_contents = dict()
+    for filepath in filepaths:
+        content = None
+
+        for file_content in files:
+            if file_content[0] == filepath:
+                content = "\n".join(file_content[1])
+                file_contents[filepath] = content
+                break
+
+        assert content is not None, "file not found"
+    return file_contents
+
+
+def correct_file_paths(model_found_files, files):
+    found_files = []
+    if model_found_files:
+        for model_file in model_found_files:
+            for file_content in files:
+                file = file_content[0]
+                if model_file == file:
+                    found_files.append(file)
+        return found_files
+    else:
+        return []
+
+
+def clean_method_left_space(method_code: str) -> str:
+    indent_space = len(method_code.splitlines()[0]) - len(
+        method_code.splitlines()[0].lstrip()
+    )
+    # remove indent_space in each line
+    return "\n".join([line[indent_space:] for line in method_code.splitlines()])
+
+
+def test_correct_file_paths():
+    # Test case 1: Exact match
+    model_files1 = ["data.txt", "analysis/report.pdf"]
+    files1 = [("data.txt",), ("notes.txt",), ("report/report.pdf",)]
+    result1 = correct_file_paths(model_files1, files1)
+    assert result1 == ["data.txt"], f"Expected ['data.txt'], but got {result1}"
+
+    # Test case 2: Subdirectories in model files
+    model_files2 = ["subdir/data.txt", "notes/info.txt"]
+    files2 = [
+        ("work/subdir/data.txt",),
+        ("notes/info.txt",),
+        ("extras/notes/info.txt",),
+    ]
+    result2 = correct_file_paths(model_files2, files2)
+    assert result2 == [
+        "work/subdir/data.txt",
+        "notes/info.txt",
+    ], f"Expected ['work/subdir/data.txt', 'notes/info.txt'], but got {result2}"
+
+    # Test case 3: No match
+    model_files3 = ["missing.txt"]
+    files3 = [("data.txt",), ("notes.txt",), ("analysis/report.pdf",)]
+    result3 = correct_file_paths(model_files3, files3)
+    assert result3 == [], f"Expected [], but got {result3}"
+
+    # Test case 4: Multiple potential matches but only first match counts
+    model_files4 = ["report.doc"]
+    files4 = [("work/report.doc",), ("work/rr/report.docg",)]
+    result4 = correct_file_paths(model_files4, files4)
+    assert result4 == [
+        "work/report.doc"
+    ], f"Expected ['work/report.doc'], but got {result4}"
+
+    # Test case 5: Model file is a subset
+    model_files5 = ["data"]
+    files5 = [("project/data_analysis/data.txt",), ("data/config.yaml",)]
+    result5 = correct_file_paths(model_files5, files5)
+    assert result5 == [], f"Expected [], but got {result5}"
+
+    # Test case 6: File without any folders with two matches
+    model_files6 = ["data.txt"]
+    files6 = [("project/data_analysis/data.txt",), ("data/config.yaml",), ("data.txt",)]
+    result6 = correct_file_paths(model_files6, files6)
+    assert result6 == ["data.txt"], f"Expected ['data.txt'], but got {result6}"
+
+    # Test case 7: File without any folders with only a subdirectory match
+    model_files7 = ["data.txt"]
+    files7 = [("project/data_analysis/data.txt",), ("data/config.yaml",)]
+    result7 = correct_file_paths(model_files7, files7)
+    assert result7 == [
+        "project/data_analysis/data.txt"
+    ], f"Expected ['project/data_analysis/data.txt'], but got {result7}"
+
+    print("All test cases passed!")
+
+
+def test_merge():
+    # Example usage:
+    input_tuples = [(1, 3), (2, 4), (5, 7), (6, 8)]
+    merged_tuples = merge_intervals(input_tuples)
+    assert merged_tuples == [(1, 4), (5, 8)]
+
+    input_tuples = [(1, 5), (2, 3)]
+    merged_tuples = merge_intervals(input_tuples)
+    assert merged_tuples == [(1, 5)]
+
+    input_tuples = [(1, 1)]
+    merged_tuples = merge_intervals(input_tuples)
+    assert merged_tuples == [(1, 1)]
+
+    input_tuples = [(1, 1), (2, 3)]
+    merged_tuples = merge_intervals(input_tuples)
+    assert merged_tuples == [(1, 1), (2, 3)]
+
+
+def test_merge():
+    # Example usage:
+    input_tuples = [(1, 3), (2, 4), (5, 7), (6, 8)]
+    merged_tuples = merge_intervals(input_tuples)
+    assert merged_tuples == [(1, 4), (5, 8)]
+
+    input_tuples = [(1, 5), (2, 3)]
+    merged_tuples = merge_intervals(input_tuples)
+    assert merged_tuples == [(1, 5)]
+
+    input_tuples = [(1, 1)]
+    merged_tuples = merge_intervals(input_tuples)
+    assert merged_tuples == [(1, 1)]
+
+    input_tuples = [(1, 1), (2, 3)]
+    merged_tuples = merge_intervals(input_tuples)
+    assert merged_tuples == [(1, 1), (2, 3)]
+
+
+def test_interval_display():
+
+    content = """
+one
+two
+three
+four
+five
+six
+seven
+eight
+""".strip()
+
+    x = line_wrap_content(content, [])
+    print(x)
+
+    print("============")
+
+    x = line_wrap_content(content, [(1, 2), (4, 6), (7, 8)])
+    print(x)
+
+
+if __name__ == "__main__":
+    test_merge()
+    test_correct_file_paths()
+    test_interval_display()

Repos/HWE/agents/Agentless/agentless/util/utils.py

@@ -0,0 +1,93 @@
+import json
+import logging
+import os
+
+
+def load_jsonl(filepath):
+    """
+    Load a JSONL file from the given filepath.
+
+    Arguments:
+    filepath -- the path to the JSONL file to load
+
+    Returns:
+    A list of dictionaries representing the data in each line of the JSONL file.
+    """
+    with open(filepath, "r") as file:
+        return [json.loads(line) for line in file]
+
+
+def write_jsonl(data, filepath):
+    """
+    Write data to a JSONL file at the given filepath.
+
+    Arguments:
+    data -- a list of dictionaries to write to the JSONL file
+    filepath -- the path to the JSONL file to write
+    """
+    with open(filepath, "w") as file:
+        for entry in data:
+            file.write(json.dumps(entry) + "\n")
+
+
+def load_json(filepath):
+    return json.load(open(filepath, "r"))
+
+
+def combine_by_instance_id(data):
+    """
+    Combine data entries by their instance ID.
+
+    Arguments:
+    data -- a list of dictionaries with instance IDs and other information
+
+    Returns:
+    A list of combined dictionaries by instance ID with all associated data.
+    """
+    combined_data = defaultdict(lambda: defaultdict(list))
+    for item in data:
+        instance_id = item.get("instance_id")
+        if not instance_id:
+            continue
+        for key, value in item.items():
+            if key != "instance_id":
+                combined_data[instance_id][key].extend(
+                    value if isinstance(value, list) else [value]
+                )
+    return [
+        {**{"instance_id": iid}, **details} for iid, details in combined_data.items()
+    ]
+
+
+def setup_logger(log_file):
+    logger = logging.getLogger(log_file)
+    logger.setLevel(logging.DEBUG)
+
+    fh = logging.FileHandler(log_file)
+    fh.setLevel(logging.DEBUG)
+
+    formatter = logging.Formatter("%(asctime)s - %(levelname)s - %(message)s")
+    fh.setFormatter(formatter)
+
+    logger.addHandler(fh)
+    return logger
+
+
+def cleanup_logger(logger):
+    handlers = logger.handlers[:]
+    for handler in handlers:
+        logger.removeHandler(handler)
+        handler.close()
+
+
+def load_existing_instance_ids(output_file):
+    instance_ids = set()
+    if os.path.exists(output_file):
+        with open(output_file, "r") as f:
+            for line in f:
+                try:
+                    data = json.loads(line.strip())
+                    instance_ids.add(data["instance_id"])
+                except json.JSONDecodeError:
+                    continue
+    return instance_ids

Repos/HWE/agents/Agentless/agentless_solutions.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d18df3fd3da6ce0a0867f94f82bc98973b2594db37cb702a30617c0e2f6c4dc1
+size 85267

Repos/HWE/agents/Agentless/batch_run.sh

@@ -0,0 +1,14 @@
+#!/usr/bin/env bash
+
+#export AGENTLESS_MODEL="gpt-5.2"
+#bash run_agentless.sh
+#export AGENTLESS_MODEL="gemini-3-pro"
+#bash run_agentless.sh
+#export AGENTLESS_MODEL="glm-4.6"
+#bash run_agentless.sh
+#export AGENTLESS_MODEL="minimax-m2"
+#bash run_agentless.sh
+export AGENTLESS_MODEL="deepseek-v3.2"
+bash run_agentless.sh
+#export AGENTLESS_MODEL="qwen3-coder-plus"
+#bash run_agentless.sh

Repos/HWE/agents/Agentless/build_dataset.py

@@ -0,0 +1,108 @@
+import argparse
+import json
+import os
+import sys
+
+
+DEFAULT_DATASET_DIR = "/workspace/phoenix-bench/data/snapshots"
+DEFAULT_ISSUES_DIR = "/workspace/phoenix-bench/data/issues"
+
+
+def read_issue_text(issues_dir, instance_id):
+    issue_path = os.path.join(issues_dir, instance_id)
+    if not os.path.isfile(issue_path):
+        return None
+    with open(issue_path, "r", encoding="utf-8") as f:
+        return f.read().strip()
+
+
+def build_dataset(dataset_dir, issues_dir):
+    entries = []
+    missing = []
+
+    for name in sorted(os.listdir(dataset_dir)):
+        repo_path = os.path.join(dataset_dir, name)
+        if not os.path.isdir(repo_path):
+            continue
+
+        problem_statement = read_issue_text(issues_dir, name)
+        if problem_statement is None:
+            missing.append(name)
+            continue
+
+        entries.append(
+            {
+                "instance_id": name,
+                "repo": repo_path,
+                "base_commit": None,
+                "problem_statement": problem_statement,
+            }
+        )
+
+    return entries, missing
+
+
+def write_output(entries, output_path, jsonl=False):
+    if jsonl:
+        with open(output_path, "w", encoding="utf-8") as f:
+            for entry in entries:
+                f.write(json.dumps(entry) + "\n")
+        return
+
+    with open(output_path, "w", encoding="utf-8") as f:
+        json.dump(entries, f, indent=2)
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description="Build Agentless dataset JSON/JSONL from local repos and issue text."
+    )
+    parser.add_argument(
+        "--dataset-dir",
+        default=DEFAULT_DATASET_DIR,
+        help="Directory containing repo subdirectories.",
+    )
+    parser.add_argument(
+        "--issues-dir",
+        default=DEFAULT_ISSUES_DIR,
+        help="Directory containing issue text files named by instance_id.",
+    )
+    parser.add_argument(
+        "--output",
+        default="/workspace/phoenix-bench/Agentless/agentless_dataset.json",
+        help="Output path (.json or .jsonl). Defaults next to dataset dir.",
+    )
+    parser.add_argument(
+        "--jsonl",
+        action="store_true",
+        help="Write JSONL instead of JSON array.",
+    )
+    return parser.parse_args()
+
+
+def main():
+    args = parse_args()
+
+    dataset_dir = os.path.abspath(args.dataset_dir)
+    issues_dir = os.path.abspath(args.issues_dir)
+    if args.output:
+        output_path = args.output
+    else:
+        suffix = ".jsonl" if args.jsonl else ".json"
+        output_path = os.path.join(
+            os.path.dirname(dataset_dir), os.path.basename(dataset_dir) + suffix
+        )
+
+    entries, missing = build_dataset(dataset_dir, issues_dir)
+    write_output(entries, output_path, jsonl=args.jsonl)
+
+    print(f"Wrote {len(entries)} entries to {output_path}")
+    if missing:
+        print(
+            "Missing issue files for: " + ", ".join(missing),
+            file=sys.stderr,
+        )
+
+
+if __name__ == "__main__":
+    main()

Repos/HWE/agents/Agentless/build_solutions.py

@@ -0,0 +1,115 @@
+#!/usr/bin/env python3
+import argparse
+import json
+from pathlib import Path
+
+
+def _safe_name(name: str) -> str:
+    return name.replace("/", "__")
+
+
+def _resolve_input_path(results_root: Path, model_name: str) -> Path:
+    candidates = []
+    for candidate_dir in [model_name, _safe_name(model_name), ""]:
+        if candidate_dir:
+            candidate = (
+                results_root / candidate_dir / "output_0_processed.jsonl"
+            ).resolve()
+        else:
+            candidate = (results_root / "output_0_processed.jsonl").resolve()
+        candidates.append(candidate)
+        if candidate.exists():
+            return candidate
+
+    joined = "\n".join(str(p) for p in candidates)
+    raise FileNotFoundError(
+        "Could not find output_0_processed.jsonl for model. Checked:\n" + joined
+    )
+
+
+def _load_jsonl(path: Path) -> list[dict]:
+    rows = []
+    with path.open("r", encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            rows.append(json.loads(line))
+    return rows
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Build OpenHands-style solutions jsonl from Agentless repair outputs."
+        )
+    )
+    parser.add_argument("--model_name", required=True, help="Model name to collect.")
+    parser.add_argument(
+        "--results_root",
+        default="/workspace/phoenix-bench/Agentless/results/hwe-bench-lite/repair_sample_verilog",
+        help="Root folder containing <model_name>/output_0_processed.jsonl.",
+    )
+    parser.add_argument(
+        "--dataset_path",
+        default="/workspace/phoenix-bench/Agentless/agentless_dataset.json",
+        help="Agentless dataset json used for repo_name mapping.",
+    )
+    parser.add_argument(
+        "--output_path",
+        default="",
+        help=(
+            "Output jsonl path. Defaults to "
+            "agentless_solutions_<model_name>_<dataset_size>.jsonl in Agentless root."
+        ),
+    )
+    args = parser.parse_args()
+
+    script_dir = Path(__file__).resolve().parent
+    results_root = Path(args.results_root).resolve()
+    dataset_path = Path(args.dataset_path).resolve()
+
+    input_path = _resolve_input_path(results_root, args.model_name)
+
+    with dataset_path.open("r", encoding="utf-8") as f:
+        dataset = json.load(f)
+
+    patches = _load_jsonl(input_path)
+    patch_by_instance = {}
+    for row in patches:
+        instance_id = row.get("instance_id")
+        if not instance_id:
+            continue
+        patch_by_instance[instance_id] = row.get("model_patch", "")
+
+    output_path = (
+        Path(args.output_path).resolve()
+        if args.output_path
+        else (
+            script_dir
+            / f"agentless_solutions_{_safe_name(args.model_name)}_{len(dataset)}.jsonl"
+        ).resolve()
+    )
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    missing = 0
+    with output_path.open("w", encoding="utf-8") as f:
+        for item in dataset:
+            instance_id = item["instance_id"]
+            solution = patch_by_instance.get(instance_id, "")
+            if instance_id not in patch_by_instance:
+                missing += 1
+            out = {
+                "repo_name": item["repo"],
+                "solution": solution,
+            }
+            f.write(json.dumps(out, ensure_ascii=False) + "\n")
+
+    print(f"Input:  {input_path}")
+    print(f"Output: {output_path}")
+    print(f"Rows:   {len(dataset)}")
+    print(f"Missing patches filled with empty solution: {missing}")
+
+
+if __name__ == "__main__":
+    main()

Repos/HWE/agents/Agentless/classification/README.md

@@ -0,0 +1,40 @@
+# SWE-bench Lite-*S* and problem classifications
+
+Here we provide our manual classifications of the problems in SWE-bench lite
+
+> [!NOTE]
+>
+> The classification results differ slightly with the paper as we have performed further manual checking and modified the classifications of few problems.
+
+## Quick Setup
+
+First install the neccessary graphing utilizies:
+
+```shell
+cd classification
+pip install -r requirements_graph.txt
+```
+
+## Graphing
+
+Run the following command to produce Figure 5 in the paper:
+
+```shell
+python graph_classification.py
+```
+
+This will produce various graphs: `benchmark_bar_location.pdf`, `benchmark_pie_description.pdf`, and `benchmark_pie_patch.pdf`
+
+For the detailed classifications, we have released our raw classifications for each problem and can be access in `swebench_lite_classifications.csv`
+
+## SWE-bench Lite-*S* problems
+
+To obtain the problems in SWE-bench Lite-*S*, run the following command:
+
+```shell
+python load_filtered_benchmark.py
+```
+
+This produces the `swebench_lite_s_problems.txt` which contains the instance_ids of the subset of problems
+
+Note: we filter out the problems that contain the exact patch in the problem description, misleading solutions, or do not provide enough information in the original issue description.

Repos/HWE/agents/Agentless/classification/graph_classification.py

@@ -0,0 +1,199 @@
+import matplotlib as mpl
+from matplotlib import pyplot as plt
+
+plt.style.use(
+    "https://github.com/dhaitz/matplotlib-stylesheets/raw/master/pacoty.mplstyle"
+)
+plt.rcParams["font.family"] = "monospace"
+plt.rcParams["font.weight"] = "bold"
+plt.rcParams.update({"font.size": 10})
+
+plt.rcParams["axes.facecolor"] = "#FFFFFF"
+plt.rcParams["axes.edgecolor"] = "black"
+
+mpl.rcParams["axes.prop_cycle"] = mpl.cycler(
+    color=[
+        "#9fc5e8",
+        "#b4a7d6",
+        "#b6d7a8",
+        "#ea9999",
+        "#d5a6bd",
+        "#8c564b",
+        "#e377c2",
+        "#7f7f7f",
+        "#bcbd22",
+        "#17becf",
+    ]
+)
+
+from load_filtered_benchmark import load_classification_results
+
+
+def graph_benchmark_classification():
+
+    instance_id_to_type = load_classification_results()
+
+    description_to_count = {}
+    description_patch_to_count = {}
+    location_to_count = {}
+    location_function_to_count = {}
+    location_file_to_count = {}
+    location_line_to_count = {}
+
+    for instance_id, classification in instance_id_to_type.items():
+        description = classification["description_classification"]
+        description_patch = classification["solution_classification"]
+        location_line = classification["line_location"]
+        location_function = classification["function_location"]
+        location_file = classification["file_location"]
+        location = classification["line_location"]
+
+        if description in description_to_count:
+            description_to_count[description] += 1
+        else:
+            description_to_count[description] = 1
+
+        if description_patch in description_patch_to_count:
+            description_patch_to_count[description_patch] += 1
+        else:
+            description_patch_to_count[description_patch] = 1
+
+        if (
+            location_line == "Natural language"
+            or location_function == "Natural language"
+            or location_file == "Natural language"
+        ):
+            location = "Natural language"
+        elif (
+            location_line == "Stacktrace"
+            or location_function == "Stacktrace"
+            or location_file == "Stacktrace"
+        ):
+            location = "Stacktrace"
+        elif (
+            location_line == "Keywords"
+            or location_function == "Keywords"
+            or location_file == "Keywords"
+        ):
+            location = "Keywords"
+        else:
+            location = "None"
+
+        if location in location_to_count:
+            location_to_count[location] += 1
+        else:
+            location_to_count[location] = 1
+
+        if location_line in location_line_to_count:
+            location_line_to_count[location_line] += 1
+        else:
+            location_line_to_count[location_line] = 1
+
+        if location_function in location_function_to_count:
+            location_function_to_count[location_function] += 1
+        else:
+            location_function_to_count[location_function] = 1
+
+        if location_file in location_file_to_count:
+            location_file_to_count[location_file] += 1
+        else:
+            location_file_to_count[location_file] = 1
+
+    fig, ax = plt.subplots(1, 1, figsize=(6, 5))
+
+    wdges, labels, autopct = ax.pie(
+        description_to_count.values(),
+        labels=[x.replace(" ", "\n") for x in description_to_count.keys()],
+        explode=[
+            0.1 if x == "Not enough info" else 0.02 for x in description_to_count.keys()
+        ],
+        autopct="%1.1f%%",
+        shadow={"ox": -0.04, "edgecolor": "none", "shade": 0.5},
+        textprops={"fontsize": 18},
+    )
+    plt.setp(labels, fontsize=12)
+    fig.tight_layout()
+    plt.savefig("benchmark_pie_description.pdf")
+
+    fig, ax = plt.subplots(1, 1, figsize=(6, 5))
+
+    wdges, labels, autopct = ax.pie(
+        description_patch_to_count.values(),
+        labels=[x.replace(" ", "\n") for x in description_patch_to_count.keys()],
+        explode=[
+            0.1 if x == "Exact patch" else 0.02
+            for x in description_patch_to_count.keys()
+        ],
+        autopct="%1.1f%%",
+        shadow={"ox": -0.04, "edgecolor": "none", "shade": 0.5},
+        startangle=90,
+        textprops={"fontsize": 18},
+    )
+    plt.setp(labels, fontsize=12)
+
+    fig.tight_layout()
+    plt.savefig("benchmark_pie_patch.pdf")
+
+    # 4 stack bar plots
+    fig, ax = plt.subplots(1, 1, figsize=(6, 5))
+
+    bottom = [0, 0, 0, 0]
+    counts = {}
+
+    width = 0.5
+
+    for loc in ["None", "Stacktrace", "Natural language", "Keywords"]:
+        if loc == "Stacktrace":
+            counts["Stack trace"] = []
+            if loc in location_line_to_count:
+                counts["Stack trace"].append(location_line_to_count[loc] / 3)
+            else:
+                counts["Stack trace"].append(0)
+
+            counts["Stack trace"].append(location_function_to_count[loc] / 3)
+            counts["Stack trace"].append(location_file_to_count[loc] / 3)
+            counts["Stack trace"].append(location_to_count[loc] / 3)
+        else:
+            counts[loc] = []
+
+            if loc in location_line_to_count:
+                counts[loc].append(location_line_to_count[loc] / 3)
+            else:
+                counts[loc].append(0)
+
+            counts[loc].append(location_function_to_count[loc] / 3)
+            counts[loc].append(location_file_to_count[loc] / 3)
+            counts[loc].append(location_to_count[loc] / 3)
+
+    for label, count in counts.items():
+        ax.bar(
+            ["Line", "Function", "File", "Overall"],
+            count,
+            bottom=bottom,
+            label=label,
+            width=width,
+        )
+        bottom = [sum(x) for x in zip(bottom, count)]
+
+        # write text
+        for i, v in enumerate(count):
+            if v == 0:
+                continue
+            ax.text(
+                i,
+                bottom[i] - v / 1.5,
+                str(round(v, 1)) + "%",
+                color="black",
+                fontweight="bold",
+                ha="center",
+                fontsize=15,
+            )
+
+    ax.set_ylabel("Percentage")
+    ax.legend(fancybox=True, shadow=True, prop={"size": 10}, frameon=True)
+    fig.tight_layout()
+    plt.savefig("benchmark_bar_location.pdf")
+
+
+if __name__ == "__main__":
+    graph_benchmark_classification()

Repos/HWE/agents/Agentless/classification/load_filtered_benchmark.py

@@ -0,0 +1,71 @@
+def load_classification_results():
+    import csv
+
+    instance_id_to_type = {}
+
+    with open("swebench_lite_classifications.csv", "r") as f:
+        reader = csv.reader(f)
+        # skip first row
+        next(reader)
+        for row in reader:
+            instance_id = row[0]
+
+            instance_id_to_type[instance_id] = {
+                "problem_statement": row[1],
+                "gt_patch": row[2],
+                "test_patch": row[3],
+                "description_classification": row[4],
+                "solution_classification": row[5],
+                "line_location": row[6],
+                "function_location": row[7],
+                "file_location": row[8],
+            }
+
+    return instance_id_to_type
+
+
+def load_swebench_s_problems():
+
+    instance_id_to_type = load_classification_results()
+    description_to_instance_id = {}
+    description_patch_to_instance_id = {}
+
+    for instance_id, instance_type in instance_id_to_type.items():
+        if (
+            instance_type["description_classification"]
+            not in description_to_instance_id
+        ):
+            description_to_instance_id[instance_type["description_classification"]] = []
+
+        description_to_instance_id[instance_type["description_classification"]].append(
+            instance_id
+        )
+
+        if (
+            instance_type["solution_classification"]
+            not in description_patch_to_instance_id
+        ):
+            description_patch_to_instance_id[
+                instance_type["solution_classification"]
+            ] = []
+
+        description_patch_to_instance_id[
+            instance_type["solution_classification"]
+        ].append(instance_id)
+
+    filtered_set = set([instance_id for instance_id in instance_id_to_type.keys()])
+
+    filtered_set = (
+        filtered_set
+        - set(description_to_instance_id["Not enough info"])
+        - set(description_patch_to_instance_id["Misleading"])
+        - set(description_patch_to_instance_id["Exact patch"])
+    )
+
+    with open("swebench_lite_s_problems.txt", "w") as f:
+        for instance_id in filtered_set:
+            f.write(instance_id + "\n")
+
+
+if __name__ == "__main__":
+    load_swebench_s_problems()

Repos/HWE/agents/Agentless/classification/requirements_graph.txt

@@ -0,0 +1,2 @@
+matplotlib
+venn

Repos/HWE/agents/Agentless/get_repo_structure/get_patch_info.py

@@ -0,0 +1,72 @@
+import argparse
+import json
+import re
+from collections import defaultdict
+
+
+def parse_patch(patch):
+    """
+    Parse a git patch into a structured format.
+
+    Parameters:
+        patch (str): The git patch as a string.
+
+    Returns:
+        list: A list of dictionaries representing the file changes and hunks.
+    """
+    file_changes = []
+    current_file = None
+    current_hunk = None
+    deleted_lines = 0
+
+    patch_lines = patch.split("\n")
+    for line in patch_lines:
+        if line.startswith("diff --git"):
+            # Reset for new files
+            if current_file:
+                file_changes.append(current_file)
+            current_file = {"file": "", "hunks": []}
+        elif line.startswith("--- a/"):
+            pass
+        elif line.startswith("+++ b/"):
+            if current_file is not None:
+                current_file["file"] = line[6:]
+        elif line.startswith("@@ "):
+            if current_file is not None:
+                match = re.match(r"@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@", line)
+                if match:
+                    current_hunk = {"start_line": int(match.group(2)), "changes": []}
+                    current_file["hunks"].append(current_hunk)
+                    deleted_lines = 0
+                    added_lines = 0
+        elif line.startswith("+") or line.startswith("-"):
+            if current_hunk is not None:
+                change_type = "add" if line.startswith("+") else "delete"
+                if change_type == "delete":
+                    deleted_lines += 1
+                    current_hunk["changes"].append(
+                        {
+                            "type": change_type,
+                            "content": line[1:].strip(),
+                            "line": current_hunk["start_line"] - added_lines,
+                        }
+                    )
+                    current_hunk["start_line"] += 1
+                else:
+                    added_lines += 1
+                    current_hunk["changes"].append(
+                        {
+                            "type": change_type,
+                            "content": line[1:].strip(),
+                            "line": current_hunk["start_line"] - deleted_lines,
+                        }
+                    )
+                    current_hunk["start_line"] += 1
+        else:
+            if current_hunk is not None:
+                current_hunk["start_line"] += 1
+
+    if current_file:
+        file_changes.append(current_file)
+
+    return file_changes

Repos/HWE/agents/Agentless/get_repo_structure/get_repo_structure.py

@@ -0,0 +1,376 @@
+import argparse
+import json
+import os
+import subprocess
+import uuid
+
+import pandas as pd
+from tqdm import tqdm
+from tree_sitter import Language, Parser
+
+repo_to_top_folder = {
+    "django/django": "django",
+    "sphinx-doc/sphinx": "sphinx",
+    "scikit-learn/scikit-learn": "scikit-learn",
+    "sympy/sympy": "sympy",
+    "pytest-dev/pytest": "pytest",
+    "matplotlib/matplotlib": "matplotlib",
+    "astropy/astropy": "astropy",
+    "pydata/xarray": "xarray",
+    "mwaskom/seaborn": "seaborn",
+    "psf/requests": "requests",
+    "pylint-dev/pylint": "pylint",
+    "pallets/flask": "flask",
+}
+
+_PARSER = None
+_MODULE_NODE_TYPES = {
+    "module_declaration",
+    "interface_declaration",
+    "program_declaration",
+    "package_declaration",
+    "class_declaration",
+    "interface_class_declaration",
+    "checker_declaration",
+    "config_declaration",
+    "primitive_declaration",
+    "udp_declaration",
+}
+_FUNC_NODE_TYPES = {
+    "function_declaration",
+    "task_declaration",
+    "function_prototype",
+    "task_prototype",
+    "method_declaration",
+    "method_prototype",
+    "class_constructor_declaration",
+    "class_constructor_prototype",
+}
+_VERILOG_EXTENSIONS = {".v", ".sv", ".vh", ".svh"}
+_ATTRIBUTE_NODE_TYPES = {"attribute_instance"}
+_SIMPLE_IDENTIFIER_NODE_TYPES = {
+    "simple_identifier",
+    "escaped_identifier",
+    "module_identifier",
+    "udp_identifier",
+}
+
+
+def _get_verilog_parser():
+    global _PARSER
+    if _PARSER is None:
+        so_path = os.environ.get("TREE_SITTER_VERILOG_SO")
+        language_name = os.environ.get("TREE_SITTER_VERILOG_LANGUAGE", "verilog")
+        if not so_path:
+            raise RuntimeError(
+                "TREE_SITTER_VERILOG_SO must point to a tree-sitter-verilog .so file"
+            )
+        if not os.path.isfile(so_path):
+            raise RuntimeError(f"tree-sitter .so not found: {so_path}")
+        try:
+            language = Language(so_path, language_name)
+        except TypeError:
+            import ctypes
+
+            symbol = os.environ.get(
+                "TREE_SITTER_VERILOG_SYMBOL", f"tree_sitter_{language_name}"
+            )
+            lib = ctypes.CDLL(so_path)
+            try:
+                func = getattr(lib, symbol)
+            except AttributeError as exc:
+                raise RuntimeError(
+                    f"tree-sitter language symbol '{symbol}' not found in {so_path}"
+                ) from exc
+            func.restype = ctypes.c_void_p
+            language = Language(func())
+        parser = Parser()
+        if hasattr(parser, "set_language"):
+            parser.set_language(language)
+        else:
+            parser.language = language
+        _PARSER = parser
+    return _PARSER
+
+
+def _node_text(node, source_bytes):
+    return source_bytes[node.start_byte : node.end_byte].decode(
+        "utf-8", errors="replace"
+    )
+
+
+def _iter_tree(node):
+    stack = [node]
+    while stack:
+        current = stack.pop()
+        yield current
+        if current.children:
+            stack.extend(reversed(current.children))
+
+
+def _find_child(node, type_set):
+    for child in node.children:
+        if child.type in type_set:
+            return child
+    return None
+
+
+def _find_identifier(node, identifier_types):
+    for child in node.children:
+        if child.type in _ATTRIBUTE_NODE_TYPES:
+            continue
+        if child.type in identifier_types:
+            return child
+    return None
+
+
+def _name_from_direct(node, source_bytes, identifier_types):
+    name_node = _find_identifier(node, identifier_types)
+    if name_node is None:
+        return None
+    return _node_text(name_node, source_bytes).strip()
+
+
+def _name_from_child(node, source_bytes, child_types, identifier_types):
+    child = _find_child(node, child_types)
+    if child is None:
+        return None
+    return _name_from_direct(child, source_bytes, identifier_types)
+
+
+def _node_key(node):
+    return (node.start_byte, node.end_byte, node.type)
+
+
+def _node_name(node, source_bytes):
+    node_type = node.type
+    if node_type == "module_declaration":
+        return _name_from_child(
+            node, source_bytes, {"module_header"}, _SIMPLE_IDENTIFIER_NODE_TYPES
+        ) or _name_from_direct(node, source_bytes, _SIMPLE_IDENTIFIER_NODE_TYPES)
+    if node_type == "udp_declaration":
+        return _name_from_child(
+            node,
+            source_bytes,
+            {"udp_nonansi_declaration", "udp_ansi_declaration"},
+            _SIMPLE_IDENTIFIER_NODE_TYPES,
+        ) or _name_from_direct(node, source_bytes, _SIMPLE_IDENTIFIER_NODE_TYPES)
+    if node_type == "interface_declaration":
+        name = _name_from_direct(node, source_bytes, {"interface_identifier"})
+        if name:
+            return name
+        return _name_from_child(
+            node,
+            source_bytes,
+            {"interface_nonansi_header", "interface_ansi_header"},
+            {"interface_identifier"},
+        )
+    if node_type == "program_declaration":
+        name = _name_from_direct(node, source_bytes, {"program_identifier"})
+        if name:
+            return name
+        return _name_from_child(
+            node,
+            source_bytes,
+            {"program_nonansi_header", "program_ansi_header"},
+            {"program_identifier"},
+        )
+    if node_type == "package_declaration":
+        return _name_from_direct(node, source_bytes, {"package_identifier"})
+    if node_type in {"class_declaration", "interface_class_declaration"}:
+        return _name_from_direct(node, source_bytes, {"class_identifier"})
+    if node_type == "checker_declaration":
+        return _name_from_direct(node, source_bytes, {"checker_identifier"})
+    if node_type == "config_declaration":
+        return _name_from_direct(node, source_bytes, {"config_identifier"})
+    if node_type == "function_declaration":
+        return _name_from_child(
+            node, source_bytes, {"function_body_declaration"}, {"function_identifier"}
+        )
+    if node_type == "task_declaration":
+        return _name_from_child(
+            node, source_bytes, {"task_body_declaration"}, {"task_identifier"}
+        )
+    if node_type == "function_prototype":
+        return _name_from_direct(node, source_bytes, {"function_identifier"})
+    if node_type == "task_prototype":
+        return _name_from_direct(node, source_bytes, {"task_identifier"})
+    if node_type in {"class_constructor_declaration", "class_constructor_prototype"}:
+        return "new"
+    return None
+
+
+def _find_enclosing_container(node, container_by_id):
+    parent = node.parent
+    while parent is not None:
+        node_key = _node_key(parent)
+        if node_key in container_by_id:
+            return container_by_id[node_key]
+        parent = parent.parent
+    return None
+
+
+def checkout_commit(repo_path, commit_id):
+    """Checkout the specified commit in the given local git repository.
+    :param repo_path: Path to the local git repository
+    :param commit_id: Commit ID to checkout
+    :return: None
+    """
+    try:
+        # Change directory to the provided repository path and checkout the specified commit
+        print(f"Checking out commit {commit_id} in repository at {repo_path}...")
+        subprocess.run(["git", "-C", repo_path, "checkout", commit_id], check=True)
+        print("Commit checked out successfully.")
+    except subprocess.CalledProcessError as e:
+        print(f"An error occurred while running git command: {e}")
+    except Exception as e:
+        print(f"An unexpected error occurred: {e}")
+
+
+def clone_repo(repo_name, repo_playground):
+    try:
+
+        print(
+            f"Cloning repository from https://github.com/{repo_name}.git to {repo_playground}/{repo_to_top_folder[repo_name]}..."
+        )
+        subprocess.run(
+            [
+                "git",
+                "clone",
+                f"https://github.com/{repo_name}.git",
+                f"{repo_playground}/{repo_to_top_folder[repo_name]}",
+            ],
+            check=True,
+        )
+        print("Repository cloned successfully.")
+    except subprocess.CalledProcessError as e:
+        print(f"An error occurred while running git command: {e}")
+    except Exception as e:
+        print(f"An unexpected error occurred: {e}")
+
+
+def get_project_structure_from_scratch(
+    repo_name, commit_id, instance_id, repo_playground
+):
+
+    # Generate a temperary folder and add uuid to avoid collision
+    repo_playground = os.path.join(repo_playground, str(uuid.uuid4()))
+
+    # assert playground doesn't exist
+    assert not os.path.exists(repo_playground), f"{repo_playground} already exists"
+
+    # create playground
+    os.makedirs(repo_playground)
+
+    #clone_repo(repo_name, repo_playground)
+    #checkout_commit(f"{repo_playground}/{repo_to_top_folder[repo_name]}", commit_id)
+    #structure = create_structure(f"{repo_playground}/{repo_to_top_folder[repo_name]}")
+    structure = create_structure(f"{repo_name}")
+    # clean up
+    #subprocess.run(
+    #    ["rm", "-rf", f"{repo_playground}/{repo_to_top_folder[repo_name]}"], check=True
+    #)
+    d = {
+        "repo": repo_name,
+        "base_commit": commit_id,
+        "structure": structure,
+        "instance_id": instance_id,
+    }
+    return d
+
+
+def parse_verilog_file(file_path, file_content=None):
+    """Parse a Verilog/SystemVerilog file with tree-sitter."""
+    if file_content is None:
+        try:
+            with open(file_path, "r") as file:
+                file_content = file.read()
+        except Exception as e:  # Catch all types of exceptions
+            print(f"Error in file {file_path}: {e}")
+            return [], [], ""
+
+    parser = _get_verilog_parser()
+    source_bytes = file_content.encode("utf-8", errors="replace")
+    tree = parser.parse(source_bytes)
+
+    class_info = []
+    function_names = []
+    container_by_id = {}
+    lines = file_content.splitlines()
+
+    for node in _iter_tree(tree.root_node):
+        if node.type not in _MODULE_NODE_TYPES:
+            continue
+
+        container_name = _node_name(node, source_bytes)
+        if not container_name:
+            continue
+        start_line = node.start_point[0] + 1
+        end_line = node.end_point[0] + 1
+
+        container_info = {
+            "name": container_name,
+            "start_line": start_line,
+            "end_line": end_line,
+            "text": lines[start_line - 1 : end_line],
+            "methods": [],
+        }
+        class_info.append(container_info)
+        container_by_id[_node_key(node)] = container_info
+
+    for node in _iter_tree(tree.root_node):
+        if node.type not in _FUNC_NODE_TYPES:
+            continue
+        func_name = _node_name(node, source_bytes)
+        if not func_name:
+            continue
+        start_line = node.start_point[0] + 1
+        end_line = node.end_point[0] + 1
+        func_info = {
+            "name": func_name,
+            "start_line": start_line,
+            "end_line": end_line,
+            "text": lines[start_line - 1 : end_line],
+        }
+        container_info = _find_enclosing_container(node, container_by_id)
+        if container_info is None:
+            function_names.append(func_info)
+        else:
+            container_info["methods"].append(func_info)
+
+    return class_info, function_names, lines
+
+
+def parse_python_file(file_path, file_content=None):
+    """Compatibility shim: parses Verilog/SystemVerilog files."""
+    return parse_verilog_file(file_path, file_content)
+
+
+def create_structure(directory_path):
+    """Create the structure of the repository directory by parsing Verilog files."""
+    structure = {}
+
+    for root, _, files in os.walk(directory_path):
+        repo_name = os.path.basename(directory_path)
+        relative_root = os.path.relpath(root, directory_path)
+        if relative_root == ".":
+            relative_root = repo_name
+        curr_struct = structure
+        for part in relative_root.split(os.sep):
+            if part not in curr_struct:
+                curr_struct[part] = {}
+            curr_struct = curr_struct[part]
+        for file_name in files:
+            _, ext = os.path.splitext(file_name)
+            if ext.lower() in _VERILOG_EXTENSIONS:
+                file_path = os.path.join(root, file_name)
+                class_info, function_names, file_lines = parse_verilog_file(file_path)
+                curr_struct[file_name] = {
+                    "classes": class_info,
+                    "functions": function_names,
+                    "text": file_lines,
+                }
+            else:
+                curr_struct[file_name] = {}
+
+    return structure

Repos/HWE/agents/Agentless/requirements.txt

@@ -0,0 +1,9 @@
+anthropic
+openai
+pre-commit
+datasets
+tiktoken
+libcst
+llama-index
+jsonlines
+swebench @ git+https://github.com/princeton-nlp/SWE-bench

Repos/HWE/agents/Agentless/run_agentless.py

@@ -0,0 +1,359 @@
+#!/usr/bin/env python3
+import argparse
+import os
+import selectors
+import subprocess
+import sys
+import time
+
+
+def _safe_model_dir_name(model_name: str) -> str:
+    return model_name.replace("/", "__")
+
+
+def _build_env():
+    env = os.environ.copy()
+    env["OPENAI_API_BASE"] = "https://api.openai.com/v1"
+    env["OPENAI_API_KEY"] = "YOUR_OPENAI_API_KEY"
+    env["TREE_SITTER_VERILOG_SO"] = "/workspace/phoenix-bench/Agentless/my-languages.so"
+    env["PYTHONPATH"] = f'{env.get("PYTHONPATH", "")}:{os.getcwd()}'
+    env["PYTHONUNBUFFERED"] = "1"
+    return env
+
+
+def run_cmd(cmd, env, cwd):
+    subprocess.run(cmd, env=env, cwd=cwd, check=True)
+
+
+def _run_cmd_streaming(cmd, env, cwd, capture_limit=1024 * 1024):
+    proc = subprocess.Popen(
+        cmd,
+        env=env,
+        cwd=cwd,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        bufsize=0,
+    )
+    sel = selectors.DefaultSelector()
+    sel.register(proc.stdout, selectors.EVENT_READ)
+    sel.register(proc.stderr, selectors.EVENT_READ)
+    captured = bytearray()
+
+    while True:
+        events = sel.select(timeout=1)
+        if events:
+            for key, _ in events:
+                data = os.read(key.fileobj.fileno(), 4096)
+                if not data:
+                    sel.unregister(key.fileobj)
+                    key.fileobj.close()
+                    continue
+                if key.fileobj is proc.stdout:
+                    sys.stdout.buffer.write(data)
+                    sys.stdout.buffer.flush()
+                else:
+                    sys.stderr.buffer.write(data)
+                    sys.stderr.buffer.flush()
+                if capture_limit:
+                    captured.extend(data)
+                    if len(captured) > capture_limit:
+                        captured = captured[-capture_limit:]
+        if proc.poll() is not None and not sel.get_map():
+            break
+
+    return proc.wait(), bytes(captured)
+
+
+def run_cmd_with_retry_on_read_timeout(cmd, env, cwd, max_retries):
+    for attempt in range(1, max_retries + 1):
+        status, output = _run_cmd_streaming(cmd, env, cwd)
+        if status == 0:
+            return
+        if b"ReadTimeout" in output:
+            if attempt < max_retries:
+                print(
+                    f"Step 3 hit a ReadTimeout (attempt {attempt}/{max_retries}), retrying..."
+                )
+                continue
+        raise SystemExit(status)
+
+
+def run_cmd_with_inactivity_timeout(cmd, env, cwd, timeout_seconds):
+    proc = subprocess.Popen(
+        cmd,
+        env=env,
+        cwd=cwd,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        bufsize=0,
+    )
+    sel = selectors.DefaultSelector()
+    sel.register(proc.stdout, selectors.EVENT_READ)
+    sel.register(proc.stderr, selectors.EVENT_READ)
+    last_output = time.monotonic()
+
+    while True:
+        events = sel.select(timeout=1)
+        if events:
+            for key, _ in events:
+                data = os.read(key.fileobj.fileno(), 4096)
+                if not data:
+                    sel.unregister(key.fileobj)
+                    key.fileobj.close()
+                    continue
+                last_output = time.monotonic()
+                if key.fileobj is proc.stdout:
+                    sys.stdout.buffer.write(data)
+                    sys.stdout.buffer.flush()
+                else:
+                    sys.stderr.buffer.write(data)
+                    sys.stderr.buffer.flush()
+        else:
+            if time.monotonic() - last_output > timeout_seconds:
+                proc.terminate()
+                try:
+                    proc.wait(timeout=5)
+                except subprocess.TimeoutExpired:
+                    proc.kill()
+                return 124
+        if proc.poll() is not None and not sel.get_map():
+            break
+
+    return proc.wait()
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--model",
+        type=str,
+        default=os.getenv("AGENTLESS_MODEL", "gpt-5.2"),
+        help="Model name for Agentless localization/repair steps.",
+    )
+    parser.add_argument(
+        "--backend",
+        type=str,
+        default="openai",
+        choices=["openai", "deepseek", "anthropic"],
+        help="Model backend for Agentless localization/repair steps.",
+    )
+    args = parser.parse_args()
+    model_dir = _safe_model_dir_name(args.model)
+
+    repo_root = "/workspace/phoenix-bench/Agentless"
+    os.chdir(repo_root)
+    env = _build_env()
+
+    dataset_path = "/workspace/phoenix-bench/Agentless/agentless_dataset.json"
+
+    steps = [
+        (
+            "1",
+            [
+                "python",
+                "agentless/fl/localize.py",
+                "--file_level",
+                "--output_folder",
+                "results/hwe-bench-lite/file_level",
+                "--num_threads",
+                "1",
+                "--skip_existing",
+                "--model",
+                args.model,
+                "--backend",
+                args.backend,
+                "--dataset_path",
+                dataset_path,
+            ],
+            False,
+        ),
+        (
+            "2",
+            [
+                "python",
+                "agentless/fl/localize.py",
+                "--file_level",
+                "--irrelevant",
+                "--output_folder",
+                "results/hwe-bench-lite/file_level_irrelevant",
+                "--num_threads",
+                "1",
+                "--skip_existing",
+                "--model",
+                args.model,
+                "--backend",
+                args.backend,
+                "--dataset_path",
+                dataset_path,
+            ],
+            False,
+        ),
+        (
+            "3",
+            [
+                "python",
+                "agentless/fl/retrieve.py",
+                "--index_type",
+                "simple",
+                "--filter_type",
+                "given_files",
+                "--filter_file",
+                "results/hwe-bench-lite/file_level_irrelevant/loc_outputs.jsonl",
+                "--output_folder",
+                "results/hwe-bench-lite/retrievel_embedding",
+                "--persist_dir",
+                "embedding/hwe-bench_simple",
+                "--num_threads",
+                "1",
+                "--dataset_path",
+                dataset_path,
+            ],
+            False,
+        ),
+        (
+            "4",
+            [
+                "python",
+                "agentless/fl/combine.py",
+                "--retrieval_loc_file",
+                "results/hwe-bench-lite/retrievel_embedding/retrieve_locs.jsonl",
+                "--model_loc_file",
+                "results/hwe-bench-lite/file_level/loc_outputs.jsonl",
+                "--top_n",
+                "3",
+                "--output_folder",
+                "results/hwe-bench-lite/file_level_combined",
+            ],
+            False,
+        ),
+        (
+            "5",
+            [
+                "python",
+                "agentless/fl/localize.py",
+                "--related_level",
+                "--output_folder",
+                "results/hwe-bench-lite/related_elements",
+                "--top_n",
+                "3",
+                "--compress_assign",
+                "--compress",
+                "--start_file",
+                "results/hwe-bench-lite/file_level_combined/combined_locs.jsonl",
+                "--num_threads",
+                "1",
+                "--skip_existing",
+                "--model",
+                args.model,
+                "--backend",
+                args.backend,
+                "--dataset_path",
+                dataset_path,
+            ],
+            False,
+        ),
+        (
+            "6",
+            [
+                "python",
+                "agentless/fl/localize.py",
+                "--fine_grain_line_level",
+                "--output_folder",
+                "results/hwe-bench-lite/edit_location_samples",
+                "--top_n",
+                "3",
+                "--compress",
+                "--temperature",
+                "0.8",
+                "--num_samples",
+                "4",
+                "--start_file",
+                "results/hwe-bench-lite/related_elements/loc_outputs.jsonl",
+                "--num_threads",
+                "1",
+                "--skip_existing",
+                "--model",
+                args.model,
+                "--backend",
+                args.backend,
+                "--dataset_path",
+                dataset_path,
+            ],
+            False,
+        ),
+        (
+            "7",
+            [
+                "python",
+                "agentless/fl/localize.py",
+                "--merge",
+                "--output_folder",
+                "results/hwe-bench-lite/edit_location_individual",
+                "--top_n",
+                "3",
+                "--num_samples",
+                "4",
+                "--start_file",
+                "results/hwe-bench-lite/edit_location_samples/loc_outputs.jsonl",
+                "--model",
+                args.model,
+                "--backend",
+                args.backend,
+                "--dataset_path",
+                dataset_path,
+            ],
+            False,
+        ),
+        (
+            "8",
+            [
+                "python",
+                "agentless/repair/repair.py",
+                "--loc_file",
+                "results/hwe-bench-lite/edit_location_individual/loc_merged_0-0_outputs.jsonl",
+                "--output_folder",
+                f"results/hwe-bench-lite/repair_sample_verilog/{model_dir}",
+                "--loc_interval",
+                "--top_n=3",
+                "--context_window=10",
+                "--max_samples",
+                "1",
+                "--cot",
+                "--diff_format",
+                "--gen_and_process",
+                "--num_threads",
+                "2",
+                "--model",
+                args.model,
+                "--backend",
+                args.backend,
+                "--dataset_path",
+                dataset_path,
+            ],
+            True,
+        ),
+    ]
+
+    for label, cmd, use_inactivity_timeout in steps:
+        print(label)
+        if label != "8":
+            continue
+        if label == "3":
+            run_cmd_with_retry_on_read_timeout(cmd, env, repo_root, max_retries=10)
+        elif use_inactivity_timeout:
+            while True:
+                status = run_cmd_with_inactivity_timeout(
+                    cmd, env, repo_root, timeout_seconds=600
+                )
+                if status == 124:
+                    print("Step 8 timed out after 600s of inactivity, retrying...")
+                    continue
+                if status != 0:
+                    raise SystemExit(status)
+                break
+        else:
+            run_cmd(cmd, env, repo_root)
+
+
+if __name__ == "__main__":
+    main()

Repos/HWE/agents/Agentless/run_agentless.sh

@@ -0,0 +1,112 @@
+export OPENAI_API_BASE=https://api.openai.com/v1
+export OPENAI_API_KEY=YOUR_OPENAI_API_KEY
+export TREE_SITTER_VERILOG_SO=/workspace/phoenix-bench/Agentless/my-languages.so
+export PYTHONPATH=$PYTHONPATH:$(pwd)
+AGENTLESS_MODEL="${AGENTLESS_MODEL:-gpt-5.2}"
+AGENTLESS_MODEL_DIR="${AGENTLESS_MODEL//\//__}"
+AGENTLESS_BACKEND="${AGENTLESS_BACKEND:-}"
+
+if [ -z "$AGENTLESS_BACKEND" ]; then
+  if [[ "$AGENTLESS_MODEL" == *deepseek* ]]; then
+    AGENTLESS_BACKEND="deepseek"
+  else
+    AGENTLESS_BACKEND="openai"
+  fi
+fi
+
+echo "1"
+python agentless/fl/localize.py --file_level \
+                                --output_folder results/hwe-bench-lite/file_level \
+                                --num_threads 10 \
+                                --skip_existing \
+                                --model "$AGENTLESS_MODEL" \
+                                --backend "$AGENTLESS_BACKEND" \
+				                --dataset_path /workspace/phoenix-bench/Agentless/agentless_dataset.json
+
+echo "2"
+python agentless/fl/localize.py --file_level \
+                                --irrelevant \
+                                --output_folder results/hwe-bench-lite/file_level_irrelevant \
+                                --num_threads 10 \
+                                --skip_existing \
+                                --model "$AGENTLESS_MODEL" \
+                                --backend "$AGENTLESS_BACKEND" \
+				                --dataset_path /workspace/phoenix-bench/Agentless/agentless_dataset.json
+
+echo "3"
+python agentless/fl/retrieve.py --index_type simple \
+                                --filter_type given_files \
+                                --filter_file results/hwe-bench-lite/file_level_irrelevant/loc_outputs.jsonl \
+                                --output_folder results/hwe-bench-lite/retrievel_embedding \
+                                --persist_dir embedding/hwe-bench_simple \
+                                --num_threads 10 \
+				                --dataset_path /workspace/phoenix-bench/Agentless/agentless_dataset.json
+
+echo "4"
+python agentless/fl/combine.py  --retrieval_loc_file results/hwe-bench-lite/retrievel_embedding/retrieve_locs.jsonl \
+                                --model_loc_file results/hwe-bench-lite/file_level/loc_outputs.jsonl \
+                                --top_n 3 \
+                                --output_folder results/hwe-bench-lite/file_level_combined 
+
+echo "5"
+python agentless/fl/localize.py --related_level \
+                                --output_folder results/hwe-bench-lite/related_elements \
+                                --top_n 3 \
+                                --compress_assign \
+                                --compress \
+                                --start_file results/hwe-bench-lite/file_level_combined/combined_locs.jsonl \
+                                --num_threads 10 \
+                                --skip_existing \
+                                --model "$AGENTLESS_MODEL" \
+                                --backend "$AGENTLESS_BACKEND" \
+				                --dataset_path /workspace/phoenix-bench/Agentless/agentless_dataset.json
+
+echo "6"
+python agentless/fl/localize.py --fine_grain_line_level \
+                                --output_folder results/hwe-bench-lite/edit_location_samples \
+                                --top_n 3 \
+                                --compress \
+                                --temperature 0.8 \
+                                --num_samples 4 \
+                                --start_file results/hwe-bench-lite/related_elements/loc_outputs.jsonl \
+                                --num_threads 10 \
+                                --skip_existing \
+                                --model "$AGENTLESS_MODEL" \
+                                --backend "$AGENTLESS_BACKEND" \
+				                --dataset_path /workspace/phoenix-bench/Agentless/agentless_dataset.json
+
+echo "7"
+python agentless/fl/localize.py --merge \
+                                --output_folder results/hwe-bench-lite/edit_location_individual \
+                                --top_n 3 \
+                                --num_samples 4 \
+                                --start_file results/hwe-bench-lite/edit_location_samples/loc_outputs.jsonl \
+                                --model "$AGENTLESS_MODEL" \
+                                --backend "$AGENTLESS_BACKEND" \
+				                --dataset_path /workspace/phoenix-bench/Agentless/agentless_dataset.json
+
+echo "8"
+while true; do
+  timeout 300s python agentless/repair/repair.py --loc_file results/hwe-bench-lite/edit_location_individual/loc_merged_0-0_outputs.jsonl \
+                                                --output_folder "results/hwe-bench-lite/repair_sample_verilog/${AGENTLESS_MODEL_DIR}" \
+                                                --loc_interval \
+                                                --top_n=3 \
+                                                --context_window=10 \
+                                                --max_samples 1  \
+                                                --cot \
+                                                --diff_format \
+                                                --gen_and_process \
+                                                --num_threads 2 \
+                                                --model "$AGENTLESS_MODEL" \
+                                                --backend "$AGENTLESS_BACKEND" \
+						                                --dataset_path /workspace/phoenix-bench/Agentless/agentless_dataset.json
+  status=$?
+  if [ $status -eq 124 ]; then
+    echo "Step 8 timed out after 300s, retrying..."
+    continue
+  fi
+  if [ $status -ne 0 ]; then
+    exit $status
+  fi
+  break
+done

Repos/HWE/agents/Agentless/tally_token_use.py

@@ -0,0 +1,352 @@
+#!/usr/bin/env python3
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from collections import defaultdict
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Any, Iterable
+
+
+DEFAULT_BASE_DIR = Path(__file__).resolve().parent / "results"
+
+
+@dataclass
+class TokenUsage:
+    records: int = 0
+    usage_objects: int = 0
+    prompt_tokens: int = 0
+    completion_tokens: int = 0
+    embedding_tokens: int = 0
+    cache_creation_tokens: int = 0
+    cache_read_tokens: int = 0
+
+    @property
+    def total_text_tokens(self) -> int:
+        return self.prompt_tokens + self.completion_tokens
+
+    @property
+    def total_tokens(self) -> int:
+        return (
+            self.prompt_tokens
+            + self.completion_tokens
+            + self.embedding_tokens
+            + self.cache_creation_tokens
+            + self.cache_read_tokens
+        )
+
+    def add_usage(self, usage: dict[str, Any]) -> None:
+        self.usage_objects += 1
+        self.prompt_tokens += first_int(
+            usage, "prompt_tokens", "input_tokens"
+        )
+        self.completion_tokens += first_int(
+            usage, "completion_tokens", "output_tokens"
+        )
+        self.embedding_tokens += first_int(usage, "embedding_tokens")
+        self.cache_creation_tokens += first_int(
+            usage, "cache_creation_token", "cache_creation_input_tokens"
+        )
+        self.cache_read_tokens += first_int(
+            usage, "cache_read_input_tokens", "cache_read_tokens"
+        )
+
+    def add_row(self, row: "TokenUsage") -> None:
+        self.records += row.records
+        self.usage_objects += row.usage_objects
+        self.prompt_tokens += row.prompt_tokens
+        self.completion_tokens += row.completion_tokens
+        self.embedding_tokens += row.embedding_tokens
+        self.cache_creation_tokens += row.cache_creation_tokens
+        self.cache_read_tokens += row.cache_read_tokens
+
+
+@dataclass
+class ModelSummary:
+    runs: int = 0
+    tokens_sent: int = 0
+    tokens_received: int = 0
+    total_tokens: int = 0
+    api_calls: int = 0
+
+    def add_usage(self, usage: TokenUsage) -> None:
+        self.runs += usage.records
+        self.tokens_sent += usage.prompt_tokens
+        self.tokens_received += usage.completion_tokens
+        self.total_tokens += usage.total_text_tokens
+        self.api_calls += usage.usage_objects
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Summarize token usage per model in Agentless JSONL outputs. By "
+            "default this scans args.json files under the repo's results/ "
+            "directory and tallies their declared output JSONL files."
+        )
+    )
+    parser.add_argument(
+        "--base-dir",
+        type=Path,
+        default=DEFAULT_BASE_DIR,
+        help="A JSONL file or directory containing Agentless result JSONL files.",
+    )
+    parser.add_argument(
+        "--format",
+        choices=("table", "json"),
+        default="table",
+        help="Output format.",
+    )
+    parser.add_argument(
+        "--include-zero-usage",
+        action="store_true",
+        help="Include models whose declared output files do not contain usage objects.",
+    )
+    return parser.parse_args()
+
+
+def first_int(mapping: dict[str, Any], *keys: str) -> int:
+    for key in keys:
+        value = mapping.get(key)
+        if value is None:
+            continue
+        try:
+            return int(value)
+        except (TypeError, ValueError):
+            continue
+    return 0
+
+
+def iter_usage_objects(value: Any) -> Iterable[dict[str, Any]]:
+    if isinstance(value, dict):
+        usage = value.get("usage")
+        if isinstance(usage, dict):
+            yield usage
+        for child in value.values():
+            yield from iter_usage_objects(child)
+    elif isinstance(value, list):
+        for child in value:
+            yield from iter_usage_objects(child)
+
+
+def iter_jsonl_files(path: Path) -> list[Path]:
+    if path.is_file():
+        if path.suffix != ".jsonl":
+            raise ValueError(f"{path} is not a .jsonl file")
+        return [path]
+    if not path.is_dir():
+        raise ValueError(f"{path} is not a file or directory")
+    return sorted(path.glob("**/*.jsonl"))
+
+
+def load_json(path: Path) -> Any:
+    with path.open(encoding="utf-8") as fh:
+        return json.load(fh)
+
+
+def format_model_name(args_data: dict[str, Any], fallback: str) -> str:
+    model = args_data.get("model")
+    backend = args_data.get("backend")
+    if isinstance(model, str) and model:
+        if isinstance(backend, str) and backend and "/" not in model:
+            return f"{backend}/{model}"
+        return model
+    return fallback
+
+
+def resolve_declared_output(args_path: Path, args_data: dict[str, Any]) -> Path | None:
+    raw_output_file = args_data.get("output_file")
+    if not isinstance(raw_output_file, str) or not raw_output_file:
+        return None
+
+    output_name = Path(raw_output_file).name
+    local_output = args_path.parent / output_name
+    if local_output.exists():
+        return local_output
+
+    raw_path = Path(raw_output_file)
+    if raw_path.is_absolute() and raw_path.exists():
+        return raw_path
+
+    repo_relative = Path(__file__).resolve().parent / raw_path
+    if repo_relative.exists():
+        return repo_relative
+
+    return None
+
+
+def infer_args_for_jsonl(path: Path) -> tuple[str, list[str]]:
+    warnings: list[str] = []
+    for parent in [path.parent, *path.parents]:
+        args_path = parent / "args.json"
+        if not args_path.exists():
+            continue
+        try:
+            args_data = load_json(args_path)
+        except (OSError, json.JSONDecodeError) as exc:
+            warnings.append(f"Ignoring unreadable args file {args_path}: {exc}")
+            continue
+        if isinstance(args_data, dict):
+            return format_model_name(args_data, path.parent.name), warnings
+    return path.parent.name, warnings
+
+
+def collect_file_usage(path: Path) -> tuple[TokenUsage, list[str]]:
+    usage = TokenUsage()
+    warnings: list[str] = []
+
+    try:
+        with path.open(encoding="utf-8") as fh:
+            for line_number, line in enumerate(fh, start=1):
+                line = line.strip()
+                if not line:
+                    continue
+                usage.records += 1
+                try:
+                    row = json.loads(line)
+                except json.JSONDecodeError as exc:
+                    warnings.append(f"Skipping malformed JSONL row {path}:{line_number}: {exc}")
+                    continue
+
+                for usage_object in iter_usage_objects(row):
+                    usage.add_usage(usage_object)
+    except OSError as exc:
+        warnings.append(f"Skipping unreadable output file {path}: {exc}")
+
+    return usage, warnings
+
+
+def collect_summary(
+    base_dir: Path, include_zero_usage: bool
+) -> tuple[dict[str, ModelSummary], list[str]]:
+    summary: dict[str, ModelSummary] = defaultdict(ModelSummary)
+    warnings: list[str] = []
+    seen_outputs: set[Path] = set()
+
+    if base_dir.is_file():
+        for path in iter_jsonl_files(base_dir):
+            model_name, model_warnings = infer_args_for_jsonl(path)
+            warnings.extend(model_warnings)
+            file_usage, file_warnings = collect_file_usage(path)
+            warnings.extend(file_warnings)
+            if file_usage.total_text_tokens or include_zero_usage:
+                summary[model_name].add_usage(file_usage)
+        return dict(summary), warnings
+
+    if not base_dir.is_dir():
+        raise ValueError(f"{base_dir} is not a file or directory")
+
+    for args_path in sorted(base_dir.glob("**/args.json")):
+        try:
+            args_data = load_json(args_path)
+        except (OSError, json.JSONDecodeError) as exc:
+            warnings.append(f"Ignoring unreadable args file {args_path}: {exc}")
+            continue
+        if not isinstance(args_data, dict):
+            warnings.append(f"Ignoring malformed args file {args_path}: top-level JSON is not an object")
+            continue
+
+        path = resolve_declared_output(args_path, args_data)
+        if path is None:
+            continue
+        path = path.resolve()
+        if path in seen_outputs:
+            continue
+        seen_outputs.add(path)
+
+        model_name = format_model_name(args_data, args_path.parent.name)
+        file_usage, file_warnings = collect_file_usage(path)
+        warnings.extend(file_warnings)
+        if file_usage.total_text_tokens or include_zero_usage:
+            summary[model_name].add_usage(file_usage)
+
+    return dict(summary), warnings
+
+
+def format_int(value: int) -> str:
+    return str(value)
+
+
+def render_table(summary: dict[str, ModelSummary]) -> str:
+    headers = [
+        "Model",
+        "Runs",
+        "Tokens Sent",
+        "Tokens Received",
+        "Total Tokens",
+        "API Calls",
+    ]
+    table_rows: list[list[str]] = []
+
+    for model_name, stats in sorted(
+        summary.items(),
+        key=lambda item: (-item[1].total_tokens, item[0]),
+    ):
+        table_rows.append(
+            [
+                model_name,
+                format_int(stats.runs),
+                format_int(stats.tokens_sent),
+                format_int(stats.tokens_received),
+                format_int(stats.total_tokens),
+                format_int(stats.api_calls),
+            ]
+        )
+
+    widths = [len(header) for header in headers]
+    for row in table_rows:
+        for index, value in enumerate(row):
+            widths[index] = max(widths[index], len(value))
+
+    def format_row(row: list[str]) -> str:
+        return "  ".join(value.ljust(widths[index]) for index, value in enumerate(row))
+
+    lines = [format_row(headers), format_row(["-" * width for width in widths])]
+    if table_rows:
+        lines.extend(format_row(row) for row in table_rows)
+    else:
+        lines.append("No token usage records found.")
+
+    return "\n".join(lines)
+
+
+def render_json(summary: dict[str, ModelSummary], base_dir: Path) -> str:
+    return json.dumps(
+        {
+            "base_dir": str(base_dir),
+            "models": {
+                model_name: asdict(stats)
+                for model_name, stats in sorted(summary.items())
+            },
+        },
+        indent=2,
+        sort_keys=True,
+    )
+
+
+def main() -> int:
+    args = parse_args()
+    base_dir = args.base_dir.resolve()
+
+    try:
+        summary, warnings = collect_summary(base_dir, args.include_zero_usage)
+    except ValueError as exc:
+        print(f"Error: {exc}", file=sys.stderr)
+        return 2
+
+    if args.format == "json":
+        print(render_json(summary, base_dir))
+    else:
+        print(render_table(summary))
+
+    for warning in warnings:
+        print(f"Warning: {warning}", file=sys.stderr)
+
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

Repos/HWE/agents/Agentless/test_agentless/apfaudio_eurorack-pmod_pr36/.gitattributes

@@ -0,0 +1 @@
+hardware/fab/* linguist-vendored

Repos/HWE/agents/Agentless/test_agentless/apfaudio_eurorack-pmod_pr36/.gitignore

@@ -0,0 +1,28 @@
+# For PCBs designed using KiCad: https://www.kicad.org/
+# Format documentation: https://kicad.org/help/file-formats/
+
+# Temporary files
+*.000
+*.bak
+*.bck
+*.kicad_pcb-bak
+*.kicad_sch-bak
+*-backups
+*.kicad_prl
+*.sch-bak
+*~
+_autosave-*
+*.tmp
+*-save.pro
+*-save.kicad_pcb
+fp-info-cache
+
+# Netlist files (exported from Eeschema)
+*.net
+
+# Autorouter files (exported from Pcbnew)
+*.dsn
+*.ses
+
+# Exported BOM files
+*.xml

Repos/HWE/agents/Agentless/test_agentless/apfaudio_eurorack-pmod_pr36/.gitmodules

@@ -0,0 +1,6 @@
+[submodule "hardware/libs/AudioJacks"]
+	path = hardware/libs/AudioJacks
+	url = https://github.com/clacktronics/AudioJacks
+[submodule "gateware/external/no2misc"]
+	path = gateware/external/no2misc
+	url = https://github.com/no2fpga/no2misc

Repos/HWE/agents/Agentless/test_agentless/apfaudio_eurorack-pmod_pr36/LICENSE

@@ -0,0 +1,289 @@
+CERN Open Hardware Licence Version 2 - Strongly Reciprocal
+
+
+Preamble
+
+CERN has developed this licence to promote collaboration among
+hardware designers and to provide a legal tool which supports the
+freedom to use, study, modify, share and distribute hardware designs
+and products based on those designs. Version 2 of the CERN Open
+Hardware Licence comes in three variants: CERN-OHL-P (permissive); and
+two reciprocal licences: CERN-OHL-W (weakly reciprocal) and this
+licence, CERN-OHL-S (strongly reciprocal).
+
+The CERN-OHL-S is copyright CERN 2020. Anyone is welcome to use it, in
+unmodified form only.
+
+Use of this Licence does not imply any endorsement by CERN of any
+Licensor or their designs nor does it imply any involvement by CERN in
+their development.
+
+
+1 Definitions
+
+  1.1 'Licence' means this CERN-OHL-S.
+
+  1.2 'Compatible Licence' means
+
+       a) any earlier version of the CERN Open Hardware licence, or
+
+       b) any version of the CERN-OHL-S, or
+
+       c) any licence which permits You to treat the Source to which
+          it applies as licensed under CERN-OHL-S provided that on
+          Conveyance of any such Source, or any associated Product You
+          treat the Source in question as being licensed under
+          CERN-OHL-S.
+
+  1.3 'Source' means information such as design materials or digital
+      code which can be applied to Make or test a Product or to
+      prepare a Product for use, Conveyance or sale, regardless of its
+      medium or how it is expressed. It may include Notices.
+
+  1.4 'Covered Source' means Source that is explicitly made available
+      under this Licence.
+
+  1.5 'Product' means any device, component, work or physical object,
+      whether in finished or intermediate form, arising from the use,
+      application or processing of Covered Source.
+
+  1.6 'Make' means to create or configure something, whether by
+      manufacture, assembly, compiling, loading or applying Covered
+      Source or another Product or otherwise.
+
+  1.7 'Available Component' means any part, sub-assembly, library or
+      code which:
+
+       a) is licensed to You as Complete Source under a Compatible
+          Licence; or
+
+       b) is available, at the time a Product or the Source containing
+          it is first Conveyed, to You and any other prospective
+          licensees
+
+            i) as a physical part with sufficient rights and
+               information (including any configuration and
+               programming files and information about its
+               characteristics and interfaces) to enable it either to
+               be Made itself, or to be sourced and used to Make the
+               Product; or
+           ii) as part of the normal distribution of a tool used to
+               design or Make the Product.
+
+  1.8 'Complete Source' means the set of all Source necessary to Make
+      a Product, in the preferred form for making modifications,
+      including necessary installation and interfacing information
+      both for the Product, and for any included Available Components.
+      If the format is proprietary, it must also be made available in
+      a format (if the proprietary tool can create it) which is
+      viewable with a tool available to potential licensees and
+      licensed under a licence approved by the Free Software
+      Foundation or the Open Source Initiative. Complete Source need
+      not include the Source of any Available Component, provided that
+      You include in the Complete Source sufficient information to
+      enable a recipient to Make or source and use the Available
+      Component to Make the Product.
+
+  1.9 'Source Location' means a location where a Licensor has placed
+      Covered Source, and which that Licensor reasonably believes will
+      remain easily accessible for at least three years for anyone to
+      obtain a digital copy.
+
+ 1.10 'Notice' means copyright, acknowledgement and trademark notices,
+      Source Location references, modification notices (subsection
+      3.3(b)) and all notices that refer to this Licence and to the
+      disclaimer of warranties that are included in the Covered
+      Source.
+
+ 1.11 'Licensee' or 'You' means any person exercising rights under
+      this Licence.
+
+ 1.12 'Licensor' means a natural or legal person who creates or
+      modifies Covered Source. A person may be a Licensee and a
+      Licensor at the same time.
+
+ 1.13 'Convey' means to communicate to the public or distribute.
+
+
+2 Applicability
+
+  2.1 This Licence governs the use, copying, modification, Conveying
+      of Covered Source and Products, and the Making of Products. By
+      exercising any right granted under this Licence, You irrevocably
+      accept these terms and conditions.
+
+  2.2 This Licence is granted by the Licensor directly to You, and
+      shall apply worldwide and without limitation in time.
+
+  2.3 You shall not attempt to restrict by contract or otherwise the
+      rights granted under this Licence to other Licensees.
+
+  2.4 This Licence is not intended to restrict fair use, fair dealing,
+      or any other similar right.
+
+
+3 Copying, Modifying and Conveying Covered Source
+
+  3.1 You may copy and Convey verbatim copies of Covered Source, in
+      any medium, provided You retain all Notices.
+
+  3.2 You may modify Covered Source, other than Notices, provided that
+      You irrevocably undertake to make that modified Covered Source
+      available from a Source Location should You Convey a Product in
+      circumstances where the recipient does not otherwise receive a
+      copy of the modified Covered Source. In each case subsection 3.3
+      shall apply.
+
+      You may only delete Notices if they are no longer applicable to
+      the corresponding Covered Source as modified by You and You may
+      add additional Notices applicable to Your modifications.
+      Including Covered Source in a larger work is modifying the
+      Covered Source, and the larger work becomes modified Covered
+      Source.
+
+  3.3 You may Convey modified Covered Source (with the effect that You
+      shall also become a Licensor) provided that You:
+
+       a) retain Notices as required in subsection 3.2;
+
+       b) add a Notice to the modified Covered Source stating that You
+          have modified it, with the date and brief description of how
+          You have modified it;
+
+       c) add a Source Location Notice for the modified Covered Source
+          if You Convey in circumstances where the recipient does not
+          otherwise receive a copy of the modified Covered Source; and
+
+       d) license the modified Covered Source under the terms and
+          conditions of this Licence (or, as set out in subsection
+          8.3, a later version, if permitted by the licence of the
+          original Covered Source). Such modified Covered Source must
+          be licensed as a whole, but excluding Available Components
+          contained in it, which remain licensed under their own
+          applicable licences.
+
+
+4 Making and Conveying Products
+
+You may Make Products, and/or Convey them, provided that You either
+provide each recipient with a copy of the Complete Source or ensure
+that each recipient is notified of the Source Location of the Complete
+Source. That Complete Source is Covered Source, and You must
+accordingly satisfy Your obligations set out in subsection 3.3. If
+specified in a Notice, the Product must visibly and securely display
+the Source Location on it or its packaging or documentation in the
+manner specified in that Notice.
+
+
+5 Research and Development
+
+You may Convey Covered Source, modified Covered Source or Products to
+a legal entity carrying out development, testing or quality assurance
+work on Your behalf provided that the work is performed on terms which
+prevent the entity from both using the Source or Products for its own
+internal purposes and Conveying the Source or Products or any
+modifications to them to any person other than You. Any modifications
+made by the entity shall be deemed to be made by You pursuant to
+subsection 3.2.
+
+
+6 DISCLAIMER AND LIABILITY
+
+  6.1 DISCLAIMER OF WARRANTY -- The Covered Source and any Products
+      are provided 'as is' and any express or implied warranties,
+      including, but not limited to, implied warranties of
+      merchantability, of satisfactory quality, non-infringement of
+      third party rights, and fitness for a particular purpose or use
+      are disclaimed in respect of any Source or Product to the
+      maximum extent permitted by law. The Licensor makes no
+      representation that any Source or Product does not or will not
+      infringe any patent, copyright, trade secret or other
+      proprietary right. The entire risk as to the use, quality, and
+      performance of any Source or Product shall be with You and not
+      the Licensor. This disclaimer of warranty is an essential part
+      of this Licence and a condition for the grant of any rights
+      granted under this Licence.
+
+  6.2 EXCLUSION AND LIMITATION OF LIABILITY -- The Licensor shall, to
+      the maximum extent permitted by law, have no liability for
+      direct, indirect, special, incidental, consequential, exemplary,
+      punitive or other damages of any character including, without
+      limitation, procurement of substitute goods or services, loss of
+      use, data or profits, or business interruption, however caused
+      and on any theory of contract, warranty, tort (including
+      negligence), product liability or otherwise, arising in any way
+      in relation to the Covered Source, modified Covered Source
+      and/or the Making or Conveyance of a Product, even if advised of
+      the possibility of such damages, and You shall hold the
+      Licensor(s) free and harmless from any liability, costs,
+      damages, fees and expenses, including claims by third parties,
+      in relation to such use.
+
+
+7 Patents
+
+  7.1 Subject to the terms and conditions of this Licence, each
+      Licensor hereby grants to You a perpetual, worldwide,
+      non-exclusive, no-charge, royalty-free, irrevocable (except as
+      stated in subsections 7.2 and 8.4) patent licence to Make, have
+      Made, use, offer to sell, sell, import, and otherwise transfer
+      the Covered Source and Products, where such licence applies only
+      to those patent claims licensable by such Licensor that are
+      necessarily infringed by exercising rights under the Covered
+      Source as Conveyed by that Licensor.
+
+  7.2 If You institute patent litigation against any entity (including
+      a cross-claim or counterclaim in a lawsuit) alleging that the
+      Covered Source or a Product constitutes direct or contributory
+      patent infringement, or You seek any declaration that a patent
+      licensed to You under this Licence is invalid or unenforceable
+      then any rights granted to You under this Licence shall
+      terminate as of the date such process is initiated.
+
+
+8 General
+
+  8.1 If any provisions of this Licence are or subsequently become
+      invalid or unenforceable for any reason, the remaining
+      provisions shall remain effective.
+
+  8.2 You shall not use any of the name (including acronyms and
+      abbreviations), image, or logo by which the Licensor or CERN is
+      known, except where needed to comply with section 3, or where
+      the use is otherwise allowed by law. Any such permitted use
+      shall be factual and shall not be made so as to suggest any kind
+      of endorsement or implication of involvement by the Licensor or
+      its personnel.
+
+  8.3 CERN may publish updated versions and variants of this Licence
+      which it considers to be in the spirit of this version, but may
+      differ in detail to address new problems or concerns. New
+      versions will be published with a unique version number and a
+      variant identifier specifying the variant. If the Licensor has
+      specified that a given variant applies to the Covered Source
+      without specifying a version, You may treat that Covered Source
+      as being released under any version of the CERN-OHL with that
+      variant. If no variant is specified, the Covered Source shall be
+      treated as being released under CERN-OHL-S. The Licensor may
+      also specify that the Covered Source is subject to a specific
+      version of the CERN-OHL or any later version in which case You
+      may apply this or any later version of CERN-OHL with the same
+      variant identifier published by CERN.
+
+  8.4 This Licence shall terminate with immediate effect if You fail
+      to comply with any of its terms and conditions.
+
+  8.5 However, if You cease all breaches of this Licence, then Your
+      Licence from any Licensor is reinstated unless such Licensor has
+      terminated this Licence by giving You, while You remain in
+      breach, a notice specifying the breach and requiring You to cure
+      it within 30 days, and You have failed to come into compliance
+      in all material respects by the end of the 30 day period. Should
+      You repeat the breach after receipt of a cure notice and
+      subsequent reinstatement, this Licence will terminate
+      immediately and permanently. Section 6 shall continue to apply
+      after any termination.
+
+  8.6 This Licence shall not be enforceable except by a Licensor
+      acting as such, and third party beneficiary rights are
+      specifically excluded.

Repos/HWE/agents/Agentless/test_agentless/apfaudio_eurorack-pmod_pr36/README.md

@@ -0,0 +1,135 @@
+# Eurorack PMOD
+
+**Assembled boards now available!** [get one **here :)**](https://lectronz.com/stores/apfelaudio)
+
+**Eurorack PMOD** makes it easy for you to combine the world of FPGAs and [hardware electronic music synthesis](https://en.wikipedia.org/wiki/Eurorack). It is an expansion board for FPGA development boards that allows them to interface with a Eurorack hardware synthesizer. This board exposes 8 (4 in + 4 out) DC-coupled audio channels, 192KHz / 32bit sampling supported, at a -8V to +8V swing, amongst many more features. R3.1 hardware looks like this:
+
+![assembled eurorack-pmod module R3.0 (panel)](docs/img/panel.jpg)
+![assembled eurorack-pmod module R3.0 (top)](docs/img/pmod_top.jpg)
+
+
+![ci workflow](https://github.com/schnommus/eurorack-pmod/actions/workflows/main.yml/badge.svg)
+
+
+For a high-level overview on R2.2 hardware, **see [my FOSDEM '23 talk](https://youtu.be/Wbd-OfCWvKU)** on this project. Production hardware is named R3+ and has a few improvements (LEDs fully programmable, jack detection, calibration EEPROM).
+
+[Want one?](#manufacturing). More photos can be found [below](#photos). 
+
+### This project is:
+- The design for a Eurorack-compatible PCB and front-panel, including a [PMOD](https://en.wikipedia.org/wiki/Pmod_Interface) connector (compatible with most FPGA dev boards). PCB designed in [KiCAD](https://www.kicad.org/). Design is [certified open hardware](https://certification.oshwa.org/de000135.html).
+- Various [example cores](gateware/cores) (and calibration / driver cores for the audio CODEC) initially targeting an [iCEBreaker FPGA](https://1bitsquared.com/products/icebreaker) (iCE40 part) but many more boards are supported (see below). Examples include calibration, sampling, effects, synthesis sources and so on. The design files can be synthesized to a bitstream using Yosys' [oss-cad-suite](https://github.com/YosysHQ/oss-cad-suite-build).
+- A [VCV Rack plugin](https://github.com/schnommus/verilog-vcvrack) so you can simulate your Verilog designs in a completely virtual modular system, no hardware required.
+
+## Included examples
+This repository contains a bunch of example DSP cores which are continuously being updated:
+- Bitcrusher
+- Filter (high pass / low pass / band pass)
+- Clock divider
+- .wav sampler
+- Pitch shifter
+- Sequential routing switch
+- Echo/delay effect
+- VCA (voltage controlled amplifier)
+- VCO (voltage controlled oscillator)
+
+These examples can all run out of the box on the development boards listed below.
+
+## Choosing an FPGA development board
+An FPGA development board itself is NOT included! Essentially anything iCE40 or ECP5 based that has a PMOD connector will support the open-source tools and the examples in this project. Just make sure you have enough LUTS, >3K is enough to do interesting things.
+
+The following development boards have been tested with `eurorack-pmod` and are supported by the examples in the github repository
+- iCEbreaker (iCE40 based)
+- ECPIX-5 (ECP5 based)
+- Colorlight i5 (ECP5 based)
+- Colorlight i9 (ECP5 based)
+- pico-ice from TinyVision (iCE40 based)
+
+## Hardware details
+
+![labelled eurorack-pmod 3.0](docs/img/labelled.jpg)
+
+- 3HP module compatible with modular synthesizer systems.
+    - Module depth is 47mm with both ribbon cables attached
+    - This fits nicely in e.g. a 4MS POD 48X (pictured below).
+- PMOD connector compatible with most FPGA development boards.
+- 8 (4 in + 4 out) DC-coupled audio channels, 192KHz / 32bit sampling supported.
+- PWM-controlled, user-programmable red/green LEDs on each output channel.
+- Jack insertion detection on input & output jacks.
+- Calibration EEPROM for unique ID and storing calibration data.
+- I/O is about +/- 8V capable, wider is possible with a resistor change.
+
+## PMOD Pinout
+
+The PMOD pinout is on the silkscreen on the back side of the board. Details are below. Note that Pin 1 is the SQUARE pad.
+
+1) SDI (AK4619VN SDIN1)
+2) SCL (I2C SCL for AK4619VN CODEC, EEPROM, LED + JACK IO expanders)
+3) SDO (AK4619VN SDOUT1)
+4) SDA (I2C SDA)
+5) LRCK (CODEC clock line)
+6) PDN (CODEC power down, also connected to LED output enable and JACK reset line -- HIGH means everything is on)
+7) BICK (CODEC clock line)
+8) MCLK (CODEC clock line)
+9) GND
+10) GND
+11) 3V3 IN
+12) 3V3 IN
+
+## Gateware details
+- Examples based on iCE40 and ECP5 based FPGAs supported by open-source tools.
+- User-defined DSP logic is decoupled from rest of system (see [`gateware/cores`](gateware/cores) directory)
+
+## Getting Started
+
+For now, I have tested builds on Linux and Windows (under MSYS2). Both are tested in CI.
+
+0. Install the [OSS FPGA CAD flow](https://github.com/yosyshq/oss-cad-suite-build).
+    - You may be able to get yosys / verilator from other package managers but I recommend using the [releases from YosysHQ](https://github.com/yosyshq/oss-cad-suite-build) so you're using the same binaries that CI is using.
+    - On Linux, once the YosysHQ suite is installed and in PATH, you should be able to just use `make` in the gateware directory.
+    - On Windows, CI is using MSYS2 with MINGW64 shell. Install MSYS2, MINGW64, extract the oss-cad-suite from YosysHQ and add it to PATH. Then you should be able to use `make` in the gateware directory.
+    - Note: The gateware is automatically built and tested in CI, so for either platform it may be helpful to look at [`.github/workflows/main.yml`](.github/workflows/main.yml).
+
+1. Build or obtain `eurorack-pmod` hardware and connect it to your FPGA development board using a ribbon cable or similar. (Double check that the pin mappings are correct, some ribbon cables will swap them on you! Default pinmaps are for the ribbon cables I shipped with hardware, you need to flip the pinmaps for a direct connection PMOD -> FPGA)
+2. Try some of the examples. From the `gateware` directory, type `make` to see valid commands. By default if you do not select a CORE it will compile a bitstream with the 'mirror' core, which just sends inputs to outputs.
+2. Calibrate your hardware using the process described in [`gateware/cal/cal.py`](gateware/cal/cal.py). Use this to create your own `gateware/cal/cal_mem.hex` to compensate for any DC biases in the ADCs/DACs. (this step is only necessary if you need sub-50mV accuracy on your inputs/outputs, which is the case if you are tuning oscillators, not so much if you are creating rhythm pulses.
+
+# Project structure
+The project is split into 2 directories, [`hardware`](hardware) for the PCB/panel and [`gateware`](gateware) for the FPGA source. Some interesting directories:
+- [`gateware/cores`](gateware/cores): example user core implementations (i.e sequential switch, bitcrusher, filter, vco, vca, sampler etc).
+- [`gateware/top.sv`](gateware/top.sv): top-level gateware with defines for selecting features.
+- [`gateware/cal/cal.py`](gateware/cal/cal.py): tool used to calibrate the hardware after assembly, generating calibration memory.
+- [`gateware/drivers`](gateware/drivers): driver for CODEC and I2C devices used on this board.
+- [`hardware/eurorack-pmod-r3`](hardware/eurorack-pmod-r3): KiCAD design files for PCB and front panel.
+- [`hardware/fab`](hardware/fab): gerber files and BOM for manufacturing the hardware.
+
+# Manufacturing
+
+**Assembled boards now available!** [get one **here :)**](https://lectronz.com/stores/apfelaudio)
+
+Update: R3.1 (first production release) is fully functional with 1 rework, see github issues for up-to-date information.
+
+Note: I gave some R3.0 (preproduction) units out at Hackaday Berlin '23. These are tested but NOT calibrated. They had 2 hacks applied. Some inductors are shorted with 0 ohm resistors as the wrong inductor was populated (means the board is a bit noiser than it should be - but still definitely useable). Also the reset line of the jack detect IO expander was routed incorrectly, so I manually shorted 2 pins of that chip. Functionally these boards are the same as R3.1, which fixes these issues.
+
+
+## Known limitations
+- Moved to github issues
+
+# Photos
+
+## Assembled `eurorack-pmod` (front)
+![assembled eurorack-pmod module (front)](docs/img/leds_front.jpg)
+
+## `eurorack-pmod` connected to iCEBreaker
+![assembled eurorack-pmod module (in system)](docs/img/pmod_insystem.jpg)
+
+# License
+
+[![OSHW logo](docs/img/oshw.svg)](https://certification.oshwa.org/de000135.html)
+
+Hardware and gateware are released under the CERN Open-Hardware License V2 `CERN-OHL-S`, mirrored in the LICENSE text in this repository.
+
+If you wish to license parts of this design in a commercial product without a reciprocal open-source license, or you have a ground-breaking idea for a module we could work on together, feel free to contact me directly. See sebholzapfel.com.
+
+*Copyright (C) 2022,2023 Sebastian Holzapfel*
+
+The above LICENSE and copyright notice does NOT apply to imported artifacts in this repository (i.e datasheets, third-party footprints).