"""Debugging task utilities - bug injection, prompt templates""" import ast import random from typing import List, Dict, Any, Optional, Tuple from rockman.benchmark.schema import Problem, TaskType BUG_PATTERNS = { "off-by-one": { "description": "Off-by-one error in loop bounds or array indexing", "inject": lambda code: inject_off_by_one(code), "tags": ["off-by-one", "logic-bug", "indexing"], }, "edge-case": { "description": "Missing edge case handling (empty, single element, null)", "inject": lambda code: inject_edge_case_bug(code), "tags": ["edge-case", "empty-input", "boundary"], }, "type-error": { "description": "Type confusion or missing type checks", "inject": lambda code: inject_type_error(code), "tags": ["type-error", "type-confusion"], }, "state-mutation": { "description": "Incorrect state mutation or shared mutable state", "inject": lambda code: inject_state_mutation(code), "tags": ["state-mutation", "side-effect"], }, "infinite-loop": { "description": "Loop termination condition never met", "inject": lambda code: inject_infinite_loop(code), "tags": ["infinite-loop", "termination"], }, "complexity-bug": { "description": "Algorithmically correct but wrong complexity class", "inject": lambda code: inject_complexity_bug(code), "tags": ["complexity-bug", "performance"], }, "recursion-bug": { "description": "Missing base case or incorrect recursive call", "inject": lambda code: inject_recursion_bug(code), "tags": ["recursion-bug", "stack-overflow"], }, "logic-bug": { "description": "General logic error in algorithm", "inject": lambda code: inject_logic_bug(code), "tags": ["logic-bug", "algorithm"], }, } def inject_off_by_one(code: str) -> str: """Inject off-by-one error.""" lines = code.split("\n") for i, line in enumerate(lines): if "range(len(" in line and ")" in line: lines[i] = line.replace("range(len(", "range(len(").replace("))", "))") if "range(len(" in lines[i] and "- 1" not in lines[i]: lines[i] = lines[i].replace("range(len(", "range(len(") if "for i in range(" in line and "len(" in line: if "- 1" not in line: lines[i] = line.replace("range(", "range(").replace("len(", "len(") return "\n".join(lines) def inject_edge_case_bug(code: str) -> str: """Remove edge case handling.""" lines = code.split("\n") new_lines = [] skip_next = False for line in lines: if skip_next: skip_next = False continue stripped = line.strip() if stripped.startswith("if not ") or stripped.startswith("if len(") == 0: skip_next = True continue if "empty" in stripped.lower() or "null" in stripped.lower() or "none" in stripped.lower(): if "return" in line or "raise" in line: skip_next = True continue new_lines.append(line) return "\n".join(new_lines) def inject_type_error(code: str) -> str: """Inject type-related bug.""" return code.replace("isinstance(", "# isinstance(").replace("type(", "# type(") def inject_state_mutation(code: str) -> str: """Inject state mutation bug.""" return code.replace("self.", "self._").replace("this.", "this._") def inject_infinite_loop(code: str) -> str: """Inject infinite loop bug.""" lines = code.split("\n") for i, line in enumerate(lines): if "while " in line and "True" in line: lines[i] = line.replace("while True:", "while True: # BUG: missing break") return "\n".join(lines) def inject_complexity_bug(code: str) -> str: """Replace efficient algorithm with inefficient one.""" if "bisect" in code or "heapq" in code: return code.replace("bisect_left", "# bisect_left").replace("heappush", "# heappush") return code def inject_recursion_bug(code: str) -> str: """Inject recursion bug.""" lines = code.split("\n") for i, line in enumerate(lines): if "def " in line and "(" in line and "):" in line: if i + 1 < len(lines): next_line = lines[i + 1].strip() if next_line.startswith("if ") and "return" in next_line: lines[i + 1] = " # BUG: base case removed" return "\n".join(lines) def inject_logic_bug(code: str) -> str: """Inject general logic bug.""" return code.replace(">=", ">").replace("<=", "<").replace("==", "!=").replace("!=", "==") def create_buggy_version(correct_code: str, bug_type: str) -> Tuple[str, str]: """Create a buggy version of correct code.""" if bug_type not in BUG_PATTERNS: bug_type = random.choice(list(BUG_PATTERNS.keys())) pattern = BUG_PATTERNS[bug_type] buggy_code = pattern["inject"](correct_code) # Ensure the bug was actually injected if buggy_code == correct_code: buggy_code = inject_logic_bug(correct_code) return buggy_code, bug_type def generate_debugging_prompt(problem: Problem, buggy_code: str, bug_type: str) -> str: """Generate prompt for debugging task.""" bug_info = BUG_PATTERNS.get(bug_type, {}) return f"""# Debugging Challenge: {bug_info.get('description', 'Fix the bug')} The following code has a bug. Identify and fix it. ## Buggy Code: ```python {buggy_code} ``` ## Problem: {problem.prompt} ## Tests (your fix must pass these): {problem.public_test} ## Instructions: 1. Analyze the buggy code to identify the issue 2. Provide the corrected implementation 3. Return ONLY the fixed function/class code """ def create_debugging_problem( base_problem: Problem, correct_solution: str, bug_type: str = None ) -> Problem: """Create a debugging task from a base problem and solution.""" if bug_type is None: bug_type = random.choice(list(BUG_PATTERNS.keys())) buggy_code, actual_bug_type = create_buggy_version(correct_solution, bug_type) debug_problem = Problem( task_id=f"{base_problem.task_id}_debug_{actual_bug_type}", category="Debugging", subcategory=actual_bug_type.replace("-", " ").title(), difficulty=base_problem.difficulty, prompt=generate_debugging_prompt(base_problem, buggy_code, actual_bug_type), public_test=base_problem.public_test, hidden_test_encrypted=base_problem.hidden_test_encrypted, hidden_test_nonce=base_problem.hidden_test_nonce, hidden_test_tag=base_problem.hidden_test_tag, time_limit=base_problem.time_limit, memory_limit=base_problem.memory_limit, language=base_problem.language, tags=base_problem.tags + ["debugging", actual_bug_type] + BUG_PATTERNS[actual_bug_type]["tags"], source_type=base_problem.source_type, expected_complexity=base_problem.expected_complexity, deterministic=base_problem.deterministic, task_type=TaskType.DEBUGGING.value, version=base_problem.version, metadata={ **base_problem.metadata, "base_task_id": base_problem.task_id, "bug_type": actual_bug_type, "buggy_code": buggy_code, "correct_solution": correct_solution, } ) return debug_problem DEBUGGING_PROMPT_TEMPLATE = """# Debugging Task: {bug_description} The following implementation contains a bug. Your task is to identify and fix it. ## Buggy Implementation: ```{language} {buggy_code} ``` ## Problem Specification: {prompt} ## Test Cases (your fix must pass all): {public_test} ## Requirements: - Fix ONLY the bug - do not change the algorithm or approach unnecessarily - Maintain the same function signature - Return the complete corrected implementation - Do not include explanations, only code """