@vk.amogh/trace 2.1.0

package/src/trace_engine/parsing/parser.py

@@ -0,0 +1,465 @@
+"""Unified code parser for Python, JavaScript, and TypeScript."""
+
+import ast
+import re
+from pathlib import Path
+from typing import List, Optional, Dict, Any
+from pydantic import BaseModel, Field
+
+from trace_engine.parsing.locations import SourceLocation
+from trace_engine.parsing.symbols import (
+    FunctionSymbol,
+    ClassSymbol,
+    ImportSymbol,
+    ParameterSymbol,
+    DecoratorSymbol,
+)
+from trace_engine.parsing.calls import CallSymbol
+from trace_engine.parsing.language import get_tree_sitter_parser
+
+
+class ParsedFile(BaseModel):
+    """Result of parsing a source file."""
+    file_path: str
+    absolute_path: Optional[str] = None
+    language: str
+    imports: List[ImportSymbol] = Field(default_factory=list)
+    classes: List[ClassSymbol] = Field(default_factory=list)
+    functions: List[FunctionSymbol] = Field(default_factory=list)
+    calls: List[CallSymbol] = Field(default_factory=list)
+
+
+class CodeParser:
+    """Parses source files into structured AST symbols and calls."""
+
+    def parse(
+        self,
+        file_path: str,
+        content: str,
+        language: str,
+        absolute_path: Optional[str] = None,
+    ) -> ParsedFile:
+        if language == "python":
+            return self._parse_python(file_path, content, absolute_path=absolute_path)
+        elif language in ("javascript", "typescript"):
+            return self._parse_js_ts(file_path, content, language, absolute_path=absolute_path)
+        elif language == "dart":
+            return self._parse_dart(file_path, content, absolute_path=absolute_path)
+        elif language in ("java", "kotlin"):
+            return self._parse_jvm(file_path, content, language, absolute_path=absolute_path)
+        elif language == "go":
+            return self._parse_go(file_path, content, absolute_path=absolute_path)
+        else:
+            return ParsedFile(file_path=file_path, absolute_path=absolute_path, language=language)
+
+    def _parse_python(
+        self, file_path: str, content: str, absolute_path: Optional[str] = None
+    ) -> ParsedFile:
+        parsed = ParsedFile(file_path=file_path, absolute_path=absolute_path, language="python")
+        try:
+            tree = ast.parse(content, filename=file_path)
+        except Exception:
+            try:
+                import textwrap
+                tree = ast.parse(textwrap.dedent(content), filename=file_path)
+            except Exception:
+                return parsed
+
+        lines = content.splitlines()
+
+        for node in ast.walk(tree):
+            # Imports
+            if isinstance(node, ast.Import):
+                for alias in node.names:
+                    parsed.imports.append(
+                        ImportSymbol(
+                            module=alias.name,
+                            alias=alias.asname,
+                            location=SourceLocation(
+                                file=file_path,
+                                line_start=node.lineno,
+                                line_end=node.end_lineno or node.lineno,
+                            ),
+                        )
+                    )
+            elif isinstance(node, ast.ImportFrom):
+                module = node.module or ""
+                names = [alias.name for alias in node.names]
+                parsed.imports.append(
+                    ImportSymbol(
+                        module=module,
+                        imported_names=names,
+                        location=SourceLocation(
+                            file=file_path,
+                            line_start=node.lineno,
+                            line_end=node.end_lineno or node.lineno,
+                        ),
+                    )
+                )
+
+        # Classes and Top-level/Class Functions
+        for node in tree.body:
+            if isinstance(node, ast.ClassDef):
+                cls_symbol = self._extract_python_class(node, file_path, lines)
+                parsed.classes.append(cls_symbol)
+                for method in cls_symbol.methods:
+                    parsed.functions.append(method)
+            elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                fn_symbol = self._extract_python_function(node, file_path, lines)
+                parsed.functions.append(fn_symbol)
+
+        # Extract calls inside functions
+        for fn in parsed.functions:
+            fn_calls = self._extract_python_calls_from_text(fn, lines, file_path)
+            parsed.calls.extend(fn_calls)
+
+        return parsed
+
+    def _extract_python_class(
+        self, node: ast.ClassDef, file_path: str, lines: List[str]
+    ) -> ClassSymbol:
+        bases = []
+        for b in node.bases:
+            if isinstance(b, ast.Name):
+                bases.append(b.id)
+            elif isinstance(b, ast.Attribute):
+                bases.append(f"{ast.unparse(b)}")
+
+        methods: List[FunctionSymbol] = []
+        for item in node.body:
+            if isinstance(item, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                methods.append(
+                    self._extract_python_function(
+                        item, file_path, lines, parent_class=node.name
+                    )
+                )
+
+        return ClassSymbol(
+            name=node.name,
+            base_classes=bases,
+            methods=methods,
+            location=SourceLocation(
+                file=file_path,
+                line_start=node.lineno,
+                line_end=node.end_lineno or node.lineno,
+            ),
+        )
+
+    def _extract_python_function(
+        self,
+        node: ast.AST,
+        file_path: str,
+        lines: List[str],
+        parent_class: Optional[str] = None,
+    ) -> FunctionSymbol:
+        is_async = isinstance(node, ast.AsyncFunctionDef)
+        name = getattr(node, "name", "unknown")
+        qualified_name = f"{parent_class}.{name}" if parent_class else name
+
+        # Parameters
+        params: List[ParameterSymbol] = []
+        args_node = getattr(node, "args", None)
+        if args_node:
+            for arg in args_node.args:
+                type_ann = ast.unparse(arg.annotation) if arg.annotation else None
+                params.append(
+                    ParameterSymbol(
+                        name=arg.arg,
+                        type_annotation=type_ann,
+                        location=SourceLocation(
+                            file=file_path,
+                            line_start=arg.lineno,
+                            line_end=arg.end_lineno or arg.lineno,
+                        ),
+                    )
+                )
+
+        # Decorators
+        decorators: List[DecoratorSymbol] = []
+        for dec in getattr(node, "decorator_list", []):
+            try:
+                dec_text = ast.unparse(dec)
+            except Exception:
+                dec_text = ""
+            dec_name = dec_text.split("(")[0].strip()
+            args = []
+            if isinstance(dec, ast.Call):
+                args = [ast.unparse(a) for a in dec.args]
+            decorators.append(
+                DecoratorSymbol(
+                    name=dec_name,
+                    arguments=args,
+                    raw_text=dec_text,
+                    location=SourceLocation(
+                        file=file_path,
+                        line_start=dec.lineno,
+                        line_end=dec.end_lineno or dec.lineno,
+                    ),
+                )
+            )
+
+        # Body snippet
+        line_start = node.lineno
+        line_end = node.end_lineno or line_start
+        body_lines = lines[line_start - 1 : line_end]
+        body_text = "\n".join(body_lines)
+
+        return FunctionSymbol(
+            name=name,
+            qualified_name=qualified_name,
+            parameters=params,
+            decorators=decorators,
+            is_async=is_async,
+            location=SourceLocation(
+                file=file_path,
+                line_start=line_start,
+                line_end=line_end,
+            ),
+            body_text=body_text,
+        )
+
+    def _extract_python_calls_from_text(
+        self, fn: FunctionSymbol, lines: List[str], file_path: str
+    ) -> List[CallSymbol]:
+        calls: List[CallSymbol] = []
+        if not fn.body_text:
+            return calls
+
+        # Match function calls e.g. db.query(...), requests.get(...), auth.check(...)
+        pattern = re.compile(r"([a-zA-Z0-9_\.]+)\s*\((.*?)\)", re.DOTALL)
+        for match in pattern.finditer(fn.body_text):
+            callee = match.group(1)
+            # Filter language keywords
+            if callee in ("def", "class", "if", "for", "while", "return", "print"):
+                continue
+            args = [a.strip() for a in match.group(2).split(",") if a.strip()]
+            calls.append(
+                CallSymbol(
+                    caller_name=fn.qualified_name,
+                    callee_name=callee,
+                    arguments=args[:5],  # store first 5 args
+                    location=fn.location,
+                )
+            )
+        return calls
+
+    def _parse_js_ts(
+        self, file_path: str, content: str, language: str, absolute_path: Optional[str] = None
+    ) -> ParsedFile:
+        parsed = ParsedFile(file_path=file_path, absolute_path=absolute_path, language=language)
+        lines = content.splitlines()
+
+        # Extract Imports: import ... from '...'; or require('...')
+        import_pat = re.compile(
+            r"""(?:import\s+.*?from\s+['"](.*?)['"]|require\s*\(\s*['"](.*?)['"]\s*\))"""
+        )
+        for idx, line in enumerate(lines, 1):
+            for match in import_pat.finditer(line):
+                mod = match.group(1) or match.group(2)
+                if mod:
+                    parsed.imports.append(
+                        ImportSymbol(
+                            module=mod,
+                            location=SourceLocation(
+                                file=file_path, line_start=idx, line_end=idx
+                            ),
+                        )
+                    )
+
+        # Extract Functions (standard function, arrow functions, function expressions)
+        fn_patterns = [
+            re.compile(r"""(?:async\s+)?function\s+([a-zA-Z0-9_$]+)\s*\((.*?)\)"""),
+            re.compile(r"""(?:const|let|var)\s+([a-zA-Z0-9_$]+)\s*=\s*(?:async\s*)?\((.*?)\)\s*=>"""),
+            re.compile(r"""(?:const|let|var)\s+([a-zA-Z0-9_$]+)\s*=\s*(?:async\s*)?function\s*\((.*?)\)"""),
+        ]
+        for idx, line in enumerate(lines, 1):
+            for pat in fn_patterns:
+                for match in pat.finditer(line):
+                    name = match.group(1)
+                    raw_args = match.group(2) or ""
+                    args = [a.strip() for a in raw_args.split(",") if a.strip()]
+                    params = [
+                        ParameterSymbol(
+                            name=arg.split(":")[0].strip(),
+                            location=SourceLocation(
+                                file=file_path, line_start=idx, line_end=idx
+                            ),
+                        )
+                        for arg in args
+                    ]
+                    parsed.functions.append(
+                        FunctionSymbol(
+                            name=name,
+                            qualified_name=name,
+                            parameters=params,
+                            location=SourceLocation(
+                                file=file_path, line_start=idx, line_end=idx
+                            ),
+                        )
+                    )
+
+        return parsed
+
+    def _parse_dart(
+        self, file_path: str, content: str, absolute_path: Optional[str] = None
+    ) -> ParsedFile:
+        parsed = ParsedFile(file_path=file_path, absolute_path=absolute_path, language="dart")
+        lines = content.splitlines()
+
+        # Imports: import 'package:...';
+        import_pat = re.compile(r"""import\s+['"](.*?)['"](?:\s+as\s+([a-zA-Z0-9_]+))?""")
+        for idx, line in enumerate(lines, 1):
+            for match in import_pat.finditer(line):
+                mod = match.group(1)
+                alias = match.group(2)
+                parsed.imports.append(
+                    ImportSymbol(
+                        module=mod,
+                        alias=alias,
+                        location=SourceLocation(file=file_path, line_start=idx, line_end=idx),
+                    )
+                )
+
+        # Classes
+        cls_pat = re.compile(r"""class\s+([a-zA-Z0-9_$]+)""")
+        for idx, line in enumerate(lines, 1):
+            for match in cls_pat.finditer(line):
+                cls_name = match.group(1)
+                parsed.classes.append(
+                    ClassSymbol(
+                        name=cls_name,
+                        location=SourceLocation(file=file_path, line_start=idx, line_end=idx),
+                    )
+                )
+
+        # Functions / Handlers / Methods
+        fn_pat = re.compile(
+            r"""(?:(?:FutureOr|Future)<[^>]+>|[a-zA-Z0-9_<>]+)\s+([a-zA-Z0-9_$]+)\s*\((.*?)\)\s*(?:async\s*)?[{=]"""
+        )
+        for idx, line in enumerate(lines, 1):
+            for match in fn_pat.finditer(line):
+                name = match.group(1)
+                if name in ("if", "for", "while", "switch", "catch"):
+                    continue
+                raw_args = match.group(2) or ""
+                args = [a.strip() for a in raw_args.split(",") if a.strip()]
+                params = [
+                    ParameterSymbol(
+                        name=arg.split()[-1].replace("?", ""),
+                        location=SourceLocation(file=file_path, line_start=idx, line_end=idx),
+                    )
+                    for arg in args
+                ]
+                parsed.functions.append(
+                    FunctionSymbol(
+                        name=name,
+                        qualified_name=name,
+                        parameters=params,
+                        location=SourceLocation(file=file_path, line_start=idx, line_end=idx),
+                    )
+                )
+
+        return parsed
+
+    def _parse_jvm(
+        self, file_path: str, content: str, language: str, absolute_path: Optional[str] = None
+    ) -> ParsedFile:
+        parsed = ParsedFile(file_path=file_path, absolute_path=absolute_path, language=language)
+        lines = content.splitlines()
+
+        # Imports
+        import_pat = re.compile(r"""import\s+([a-zA-Z0-9_\.\*]+);?""")
+        for idx, line in enumerate(lines, 1):
+            for match in import_pat.finditer(line):
+                parsed.imports.append(
+                    ImportSymbol(
+                        module=match.group(1),
+                        location=SourceLocation(file=file_path, line_start=idx, line_end=idx),
+                    )
+                )
+
+        # Classes
+        cls_pat = re.compile(r"""(?:public\s+|private\s+|protected\s+|open\s+)?class\s+([a-zA-Z0-9_$]+)""")
+        for idx, line in enumerate(lines, 1):
+            for match in cls_pat.finditer(line):
+                parsed.classes.append(
+                    ClassSymbol(
+                        name=match.group(1),
+                        location=SourceLocation(file=file_path, line_start=idx, line_end=idx),
+                    )
+                )
+
+        # Functions (Kotlin 'fun' & Java methods)
+        if language == "kotlin":
+            fn_pat = re.compile(r"""fun\s+([a-zA-Z0-9_$]+)\s*\((.*?)\)""")
+        else:
+            fn_pat = re.compile(r"""(?:public|protected|private)?\s*(?:static\s+)?(?:final\s+)?(?:[a-zA-Z0-9_<>,\[\]]+)\s+([a-zA-Z0-9_$]+)\s*\((.*?)\)""")
+
+        for idx, line in enumerate(lines, 1):
+            for match in fn_pat.finditer(line):
+                name = match.group(1)
+                if name in ("if", "for", "while", "switch", "catch", "return", "class"):
+                    continue
+                raw_args = match.group(2) or ""
+                args = [a.strip() for a in raw_args.split(",") if a.strip()]
+                params = [
+                    ParameterSymbol(
+                        name=arg.split()[-1] if language != "kotlin" else arg.split(":")[0].strip(),
+                        location=SourceLocation(file=file_path, line_start=idx, line_end=idx),
+                    )
+                    for arg in args
+                ]
+                parsed.functions.append(
+                    FunctionSymbol(
+                        name=name,
+                        qualified_name=name,
+                        parameters=params,
+                        location=SourceLocation(file=file_path, line_start=idx, line_end=idx),
+                    )
+                )
+
+        return parsed
+
+    def _parse_go(
+        self, file_path: str, content: str, absolute_path: Optional[str] = None
+    ) -> ParsedFile:
+        parsed = ParsedFile(file_path=file_path, absolute_path=absolute_path, language="go")
+        lines = content.splitlines()
+
+        # Imports
+        import_pat = re.compile(r'''(?:import\s+['"](.*?)['"]|import\s*\((.*?)\))''', re.DOTALL)
+        for idx, line in enumerate(lines, 1):
+            m = re.search(r'''import\s+['"](.*?)['"]''', line)
+            if m:
+                parsed.imports.append(
+                    ImportSymbol(
+                        module=m.group(1),
+                        location=SourceLocation(file=file_path, line_start=idx, line_end=idx),
+                    )
+                )
+
+        # Functions
+        fn_pat = re.compile(r"""func\s+(?:\([^\)]+\)\s+)?([a-zA-Z0-9_]+)\s*\((.*?)\)""")
+        for idx, line in enumerate(lines, 1):
+            for match in fn_pat.finditer(line):
+                name = match.group(1)
+                raw_args = match.group(2) or ""
+                args = [a.strip() for a in raw_args.split(",") if a.strip()]
+                params = [
+                    ParameterSymbol(
+                        name=arg.split()[0],
+                        location=SourceLocation(file=file_path, line_start=idx, line_end=idx),
+                    )
+                    for arg in args
+                ]
+                parsed.functions.append(
+                    FunctionSymbol(
+                        name=name,
+                        qualified_name=name,
+                        parameters=params,
+                        location=SourceLocation(file=file_path, line_start=idx, line_end=idx),
+                    )
+                )
+
+        return parsed
+

package/src/trace_engine/parsing/symbols.py

@@ -0,0 +1,45 @@
+"""Symbol definitions extracted from AST parsing."""
+
+from typing import List, Optional, Dict, Any
+from pydantic import BaseModel, Field
+from trace_engine.parsing.locations import SourceLocation
+
+
+class ParameterSymbol(BaseModel):
+    name: str
+    type_annotation: Optional[str] = None
+    default_value: Optional[str] = None
+    location: SourceLocation
+
+
+class DecoratorSymbol(BaseModel):
+    name: str
+    arguments: List[str] = Field(default_factory=list)
+    raw_text: str
+    location: SourceLocation
+
+
+class FunctionSymbol(BaseModel):
+    name: str
+    qualified_name: str
+    parameters: List[ParameterSymbol] = Field(default_factory=list)
+    decorators: List[DecoratorSymbol] = Field(default_factory=list)
+    docstring: Optional[str] = None
+    is_async: bool = False
+    return_type: Optional[str] = None
+    location: SourceLocation
+    body_text: Optional[str] = None
+
+
+class ClassSymbol(BaseModel):
+    name: str
+    base_classes: List[str] = Field(default_factory=list)
+    methods: List[FunctionSymbol] = Field(default_factory=list)
+    location: SourceLocation
+
+
+class ImportSymbol(BaseModel):
+    module: str
+    imported_names: List[str] = Field(default_factory=list)
+    alias: Optional[str] = None
+    location: SourceLocation

package/src/trace_engine/plugin/__init__.py

@@ -0,0 +1,157 @@
+"""TRACE Agent Harness Plugin - Core Interface.
+
+Allows any AI coding agent harness (SWE-bench, Antigravity, OpenHands, Aider, Claude Code)
+to plug in TRACE for autonomous vulnerability benchmark generation, attack-path modeling,
+and deterministic verification.
+"""
+
+import os
+import shutil
+import logging
+from pathlib import Path
+from typing import List, Optional, Dict, Any
+
+from trace_engine.findings.store import FindingStore
+from trace_engine.plugin.task import HarnessTaskSpec
+from trace_engine.plugin.swebench_adapter import build_harness_task, export_swebench_jsonl
+from trace_engine.plugin.evaluator import HarnessEvaluator, EvaluationResult
+
+logger = logging.getLogger("trace_harness_plugin")
+
+
+class TraceHarnessPlugin:
+    """Agent Harness Plugin interface for TRACE security evaluation and verification."""
+
+    PLUGIN_NAME = "trace-security"
+    VERSION = "2.0.0"
+
+    def __init__(self, repo_path: Optional[Path] = None, target_url: str = "http://127.0.0.1:18080"):
+        self.repo_path = Path(repo_path or ".").resolve()
+        self.target_url = target_url
+        self.finding_store = FindingStore(self.repo_path / ".trace")
+        self.evaluator = HarnessEvaluator(self.repo_path, target_url=self.target_url)
+
+    def list_tasks(self) -> List[HarnessTaskSpec]:
+        """Generate benchmark task instances for all correlated vulnerabilities found in the repo."""
+        findings = self.finding_store.load_findings()
+        tasks: List[HarnessTaskSpec] = []
+        for f in findings:
+            task = build_harness_task(f, self.repo_path)
+            tasks.append(task)
+        return tasks
+
+    def get_task(self, identifier: str) -> Optional[HarnessTaskSpec]:
+        """Retrieve task by instance ID or finding ID."""
+        for t in self.list_tasks():
+            if t.instance_id == identifier or t.finding_id == identifier:
+                return t
+        return None
+
+    def evaluate_patch(
+        self,
+        finding_id: str,
+        patch_content: Optional[str] = None,
+        target_file: Optional[str] = None,
+        rollback_after: bool = False,
+    ) -> EvaluationResult:
+        """Evaluate a patch produced by an external agent against the ground-truth verification oracle."""
+        return self.evaluator.evaluate_patch(
+            finding_id=finding_id,
+            patch_content=patch_content,
+            target_file=target_file,
+            rollback_after=rollback_after,
+        )
+
+    def export_dataset(self, output_path: Optional[Path] = None) -> Path:
+        """Export all benchmark tasks to standard SWE-bench JSONL format."""
+        out = output_path or (self.repo_path / "trace_bench_tasks.jsonl")
+        tasks = self.list_tasks()
+        export_swebench_jsonl(tasks, out)
+        return out
+
+    @staticmethod
+    def get_plugin_template_dir() -> Path:
+        """Locate the plugin template directory bundled with TRACE."""
+        # Check workspace first, then module directory
+        module_plugin = Path(__file__).resolve().parent / "bundle"
+        return module_plugin
+
+    def install(self, workspace_mode: bool = True, global_mode: bool = False) -> Dict[str, Path]:
+        """Installs the TRACE plugin into workspace .agents/plugins/ or global ~/.gemini/config/plugins/."""
+        installed_locations: Dict[str, Path] = {}
+
+        bundle_dir = self.get_plugin_template_dir()
+        if not bundle_dir.exists():
+            raise FileNotFoundError(f"Plugin template directory not found at {bundle_dir}")
+
+        if workspace_mode:
+            ws_dest = self.repo_path / ".agents" / "plugins" / self.PLUGIN_NAME
+            ws_dest.mkdir(parents=True, exist_ok=True)
+            self._copy_bundle(bundle_dir, ws_dest)
+            installed_locations["workspace"] = ws_dest
+
+            # Direct agent skill directory (.agents/skills/trace-security-harness/)
+            skill_src = bundle_dir / "skills" / "trace-security-harness"
+            if skill_src.exists():
+                skill_dest = self.repo_path / ".agents" / "skills" / "trace-security-harness"
+                skill_dest.mkdir(parents=True, exist_ok=True)
+                self._copy_bundle(skill_src, skill_dest)
+                installed_locations["agent_skill"] = skill_dest
+
+            # Claude Code skill integration (.claude/skills/trace-security/)
+            claude_skill_dest = self.repo_path / ".claude" / "skills" / "trace-security"
+            if skill_src.exists():
+                claude_skill_dest.mkdir(parents=True, exist_ok=True)
+                self._copy_bundle(skill_src, claude_skill_dest)
+                installed_locations["claude_skill"] = claude_skill_dest
+
+            # Generate or update .mcp.json for Claude Code and Cursor
+            from trace_engine.mcp.config import generate_mcp_json
+            try:
+                mcp_file = generate_mcp_json(self.repo_path)
+                installed_locations["mcp"] = mcp_file
+                # Cursor MCP configuration (.cursor/mcp.json)
+                cursor_mcp = self.repo_path / ".cursor" / "mcp.json"
+                cursor_mcp.parent.mkdir(parents=True, exist_ok=True)
+                shutil.copy2(mcp_file, cursor_mcp)
+                installed_locations["cursor_mcp"] = cursor_mcp
+            except Exception:
+                pass
+
+        if global_mode:
+            home = Path.home()
+            global_dest = home / ".gemini" / "config" / "plugins" / self.PLUGIN_NAME
+            global_dest.mkdir(parents=True, exist_ok=True)
+            self._copy_bundle(bundle_dir, global_dest)
+            installed_locations["global"] = global_dest
+
+            # Global Claude configuration (~/.claude/skills/trace-security/)
+            global_claude = home / ".claude" / "skills" / "trace-security"
+            skill_src = bundle_dir / "skills" / "trace-security-harness"
+            if skill_src.exists():
+                global_claude.mkdir(parents=True, exist_ok=True)
+                self._copy_bundle(skill_src, global_claude)
+                installed_locations["global_claude"] = global_claude
+
+        return installed_locations
+
+    def _copy_bundle(self, src: Path, dest: Path) -> None:
+        """Copy all files from plugin bundle into destination."""
+        for item in src.rglob("*"):
+            rel = item.relative_to(src)
+            target = dest / rel
+            if item.is_dir():
+                target.mkdir(parents=True, exist_ok=True)
+            else:
+                target.parent.mkdir(parents=True, exist_ok=True)
+                shutil.copy2(item, target)
+
+
+__all__ = [
+    "TraceHarnessPlugin",
+    "HarnessTaskSpec",
+    "HarnessEvaluator",
+    "EvaluationResult",
+    "build_harness_task",
+    "export_swebench_jsonl",
+]