653 lines
19 KiB
Python
653 lines
19 KiB
Python
|
"""
|
||
|
|
CLI Bridge - Execute AI tasks through Claude Code CLI and OpenCode CLI.
|
||
|
|
|
||
|
|
Uses your existing subscriptions via CLI tools:
|
||
|
|
- Claude Code CLI (claude.exe) for implementation
|
||
|
|
- OpenCode CLI (opencode) for Gemini planning
|
||
|
|
|
||
|
|
No API keys needed - leverages your CLI subscriptions.
|
||
|
|
"""
|
||
|
|
|
||
|
|
import asyncio
|
||
|
|
import json
|
||
|
|
import logging
|
||
|
|
import os
|
||
|
|
import subprocess
|
||
|
|
import tempfile
|
||
|
|
from dataclasses import dataclass
|
||
|
|
from datetime import datetime
|
||
|
|
from pathlib import Path
|
||
|
|
from typing import Any, Dict, List, Optional, Tuple
|
||
|
|
import re
|
||
|
|
|
||
|
|
logger = logging.getLogger(__name__)
|
||
|
|
|
||
|
|
|
||
|
|
@dataclass
|
||
|
|
class CLIResult:
|
||
|
|
"""Result from CLI execution."""
|
||
|
|
|
||
|
|
success: bool
|
||
|
|
output: str
|
||
|
|
error: str
|
||
|
|
duration_seconds: float
|
||
|
|
files_modified: List[str]
|
||
|
|
|
||
|
|
|
||
|
|
class ClaudeCodeCLI:
|
||
|
|
"""
|
||
|
|
Execute tasks through Claude Code CLI.
|
||
|
|
|
||
|
|
Uses: claude.exe --print for non-interactive execution
|
||
|
|
"""
|
||
|
|
|
||
|
|
CLAUDE_PATH = r"C:\Users\antoi\.local\bin\claude.exe"
|
||
|
|
|
||
|
|
def __init__(self, workspace: Path):
|
||
|
|
self.workspace = workspace
|
||
|
|
|
||
|
|
async def execute(
|
||
|
|
self,
|
||
|
|
prompt: str,
|
||
|
|
timeout: int = 300,
|
||
|
|
model: str = "opus",
|
||
|
|
) -> CLIResult:
|
||
|
|
"""
|
||
|
|
Execute a prompt through Claude Code CLI.
|
||
|
|
|
||
|
|
Args:
|
||
|
|
prompt: The instruction/prompt to execute
|
||
|
|
timeout: Timeout in seconds
|
||
|
|
model: Model to use (opus, sonnet, haiku)
|
||
|
|
|
||
|
|
Returns:
|
||
|
|
CLIResult with output and modified files
|
||
|
|
"""
|
||
|
|
start_time = datetime.now()
|
||
|
|
|
||
|
|
# Build command
|
||
|
|
cmd = [
|
||
|
|
self.CLAUDE_PATH,
|
||
|
|
"--print", # Non-interactive mode
|
||
|
|
"--model",
|
||
|
|
model,
|
||
|
|
"--permission-mode",
|
||
|
|
"acceptEdits", # Auto-accept edits
|
||
|
|
prompt,
|
||
|
|
]
|
||
|
|
|
||
|
|
logger.info(f"Executing Claude Code CLI: {prompt[:100]}...")
|
||
|
|
|
||
|
|
try:
|
||
|
|
# Run in workspace directory
|
||
|
|
result = subprocess.run(
|
||
|
|
cmd,
|
||
|
|
capture_output=True,
|
||
|
|
text=True,
|
||
|
|
timeout=timeout,
|
||
|
|
cwd=str(self.workspace),
|
||
|
|
env={**os.environ, "TERM": "dumb"}, # Disable colors
|
||
|
|
)
|
||
|
|
|
||
|
|
output = result.stdout
|
||
|
|
error = result.stderr
|
||
|
|
success = result.returncode == 0
|
||
|
|
|
||
|
|
# Extract modified files from output
|
||
|
|
files_modified = self._extract_modified_files(output)
|
||
|
|
|
||
|
|
duration = (datetime.now() - start_time).total_seconds()
|
||
|
|
|
||
|
|
logger.info(
|
||
|
|
f"Claude Code completed in {duration:.1f}s, modified {len(files_modified)} files"
|
||
|
|
)
|
||
|
|
|
||
|
|
return CLIResult(
|
||
|
|
success=success,
|
||
|
|
output=output,
|
||
|
|
error=error,
|
||
|
|
duration_seconds=duration,
|
||
|
|
files_modified=files_modified,
|
||
|
|
)
|
||
|
|
|
||
|
|
except subprocess.TimeoutExpired:
|
||
|
|
return CLIResult(
|
||
|
|
success=False,
|
||
|
|
output="",
|
||
|
|
error=f"Timeout after {timeout}s",
|
||
|
|
duration_seconds=timeout,
|
||
|
|
files_modified=[],
|
||
|
|
)
|
||
|
|
except Exception as e:
|
||
|
|
return CLIResult(
|
||
|
|
success=False,
|
||
|
|
output="",
|
||
|
|
error=str(e),
|
||
|
|
duration_seconds=(datetime.now() - start_time).total_seconds(),
|
||
|
|
files_modified=[],
|
||
|
|
)
|
||
|
|
|
||
|
|
def _extract_modified_files(self, output: str) -> List[str]:
|
||
|
|
"""Extract list of modified files from Claude Code output."""
|
||
|
|
files = []
|
||
|
|
|
||
|
|
# Look for file modification patterns
|
||
|
|
patterns = [
|
||
|
|
r"(?:Created|Modified|Wrote|Updated|Edited):\s*[`'\"]?([^\s`'\"]+)[`'\"]?",
|
||
|
|
r"Writing to [`'\"]?([^\s`'\"]+)[`'\"]?",
|
||
|
|
r"File saved: ([^\s]+)",
|
||
|
|
]
|
||
|
|
|
||
|
|
for pattern in patterns:
|
||
|
|
matches = re.findall(pattern, output, re.IGNORECASE)
|
||
|
|
files.extend(matches)
|
||
|
|
|
||
|
|
return list(set(files))
|
||
|
|
|
||
|
|
async def execute_with_context(
|
||
|
|
self,
|
||
|
|
prompt: str,
|
||
|
|
context_files: List[str],
|
||
|
|
timeout: int = 300,
|
||
|
|
) -> CLIResult:
|
||
|
|
"""
|
||
|
|
Execute with additional context files loaded.
|
||
|
|
|
||
|
|
Args:
|
||
|
|
prompt: The instruction
|
||
|
|
context_files: Files to read as context
|
||
|
|
timeout: Timeout in seconds
|
||
|
|
"""
|
||
|
|
# Build prompt with context
|
||
|
|
context_prompt = prompt
|
||
|
|
|
||
|
|
if context_files:
|
||
|
|
context_prompt += "\n\nContext files to consider:\n"
|
||
|
|
for f in context_files:
|
||
|
|
context_prompt += f"- {f}\n"
|
||
|
|
|
||
|
|
return await self.execute(context_prompt, timeout)
|
||
|
|
|
||
|
|
|
||
|
|
class OpenCodeCLI:
|
||
|
|
"""
|
||
|
|
Execute tasks through OpenCode CLI (Gemini).
|
||
|
|
|
||
|
|
Uses: opencode run for non-interactive execution
|
||
|
|
"""
|
||
|
|
|
||
|
|
OPENCODE_PATH = r"C:\Users\antoi\AppData\Roaming\npm\opencode.cmd"
|
||
|
|
|
||
|
|
def __init__(self, workspace: Path):
|
||
|
|
self.workspace = workspace
|
||
|
|
|
||
|
|
async def execute(
|
||
|
|
self,
|
||
|
|
prompt: str,
|
||
|
|
timeout: int = 180,
|
||
|
|
model: str = "google/gemini-3-pro-preview",
|
||
|
|
) -> CLIResult:
|
||
|
|
"""
|
||
|
|
Execute a prompt through OpenCode CLI.
|
||
|
|
|
||
|
|
Args:
|
||
|
|
prompt: The instruction/prompt
|
||
|
|
timeout: Timeout in seconds
|
||
|
|
model: Model to use
|
||
|
|
|
||
|
|
Returns:
|
||
|
|
CLIResult with output
|
||
|
|
"""
|
||
|
|
start_time = datetime.now()
|
||
|
|
|
||
|
|
# Build command
|
||
|
|
cmd = [self.OPENCODE_PATH, "run", "--model", model, prompt]
|
||
|
|
|
||
|
|
logger.info(f"Executing OpenCode CLI: {prompt[:100]}...")
|
||
|
|
|
||
|
|
try:
|
||
|
|
result = subprocess.run(
|
||
|
|
cmd,
|
||
|
|
capture_output=True,
|
||
|
|
text=True,
|
||
|
|
timeout=timeout,
|
||
|
|
cwd=str(self.workspace),
|
||
|
|
env={**os.environ, "TERM": "dumb"},
|
||
|
|
)
|
||
|
|
|
||
|
|
output = result.stdout
|
||
|
|
error = result.stderr
|
||
|
|
success = result.returncode == 0
|
||
|
|
|
||
|
|
duration = (datetime.now() - start_time).total_seconds()
|
||
|
|
|
||
|
|
logger.info(f"OpenCode completed in {duration:.1f}s")
|
||
|
|
|
||
|
|
return CLIResult(
|
||
|
|
success=success,
|
||
|
|
output=output,
|
||
|
|
error=error,
|
||
|
|
duration_seconds=duration,
|
||
|
|
files_modified=[], # OpenCode typically doesn't modify files directly
|
||
|
|
)
|
||
|
|
|
||
|
|
except subprocess.TimeoutExpired:
|
||
|
|
return CLIResult(
|
||
|
|
success=False,
|
||
|
|
output="",
|
||
|
|
error=f"Timeout after {timeout}s",
|
||
|
|
duration_seconds=timeout,
|
||
|
|
files_modified=[],
|
||
|
|
)
|
||
|
|
except Exception as e:
|
||
|
|
return CLIResult(
|
||
|
|
success=False,
|
||
|
|
output="",
|
||
|
|
error=str(e),
|
||
|
|
duration_seconds=(datetime.now() - start_time).total_seconds(),
|
||
|
|
files_modified=[],
|
||
|
|
)
|
||
|
|
|
||
|
|
async def plan(self, objective: str, context: Dict = None) -> Dict:
|
||
|
|
"""
|
||
|
|
Create an implementation plan using Gemini via OpenCode.
|
||
|
|
|
||
|
|
Args:
|
||
|
|
objective: What to achieve
|
||
|
|
context: Additional context
|
||
|
|
|
||
|
|
Returns:
|
||
|
|
Plan dict with tasks and test scenarios
|
||
|
|
"""
|
||
|
|
prompt = f"""You are a strategic planner for Atomizer, an FEA optimization framework.
|
||
|
|
|
||
|
|
## Objective
|
||
|
|
{objective}
|
||
|
|
|
||
|
|
## Context
|
||
|
|
{json.dumps(context, indent=2) if context else "None provided"}
|
||
|
|
|
||
|
|
## Task
|
||
|
|
Create a detailed implementation plan in JSON format with:
|
||
|
|
1. tasks: List of implementation tasks for Claude Code
|
||
|
|
2. test_scenarios: Tests to verify implementation
|
||
|
|
3. acceptance_criteria: Success conditions
|
||
|
|
|
||
|
|
Output ONLY valid JSON in this format:
|
||
|
|
```json
|
||
|
|
{{
|
||
|
|
"objective": "{objective}",
|
||
|
|
"approach": "Brief description",
|
||
|
|
"tasks": [
|
||
|
|
{{
|
||
|
|
"id": "task_001",
|
||
|
|
"description": "What to do",
|
||
|
|
"file": "path/to/file.py",
|
||
|
|
"priority": "high"
|
||
|
|
}}
|
||
|
|
],
|
||
|
|
"test_scenarios": [
|
||
|
|
{{
|
||
|
|
"id": "test_001",
|
||
|
|
"name": "Test name",
|
||
|
|
"type": "filesystem",
|
||
|
|
"steps": [{{"action": "check_exists", "path": "some/path"}}],
|
||
|
|
"expected_outcome": {{"exists": true}}
|
||
|
|
}}
|
||
|
|
],
|
||
|
|
"acceptance_criteria": [
|
||
|
|
"Criterion 1"
|
||
|
|
]
|
||
|
|
}}
|
||
|
|
```
|
||
|
|
"""
|
||
|
|
|
||
|
|
result = await self.execute(prompt)
|
||
|
|
|
||
|
|
if not result.success:
|
||
|
|
logger.error(f"OpenCode planning failed: {result.error}")
|
||
|
|
return self._fallback_plan(objective, context)
|
||
|
|
|
||
|
|
# Parse JSON from output
|
||
|
|
try:
|
||
|
|
# Find JSON block in output
|
||
|
|
output = result.output
|
||
|
|
|
||
|
|
if "```json" in output:
|
||
|
|
start = output.find("```json") + 7
|
||
|
|
end = output.find("```", start)
|
||
|
|
json_str = output[start:end].strip()
|
||
|
|
elif "```" in output:
|
||
|
|
start = output.find("```") + 3
|
||
|
|
end = output.find("```", start)
|
||
|
|
json_str = output[start:end].strip()
|
||
|
|
else:
|
||
|
|
# Try to find JSON object directly
|
||
|
|
match = re.search(r"\{.*\}", output, re.DOTALL)
|
||
|
|
if match:
|
||
|
|
json_str = match.group()
|
||
|
|
else:
|
||
|
|
return self._fallback_plan(objective, context)
|
||
|
|
|
||
|
|
plan = json.loads(json_str)
|
||
|
|
logger.info(f"Plan created with {len(plan.get('tasks', []))} tasks")
|
||
|
|
return plan
|
||
|
|
|
||
|
|
except json.JSONDecodeError as e:
|
||
|
|
logger.error(f"Failed to parse plan JSON: {e}")
|
||
|
|
return self._fallback_plan(objective, context)
|
||
|
|
|
||
|
|
def _fallback_plan(self, objective: str, context: Dict = None) -> Dict:
|
||
|
|
"""Generate a fallback plan when Gemini fails."""
|
||
|
|
logger.warning("Using fallback plan")
|
||
|
|
|
||
|
|
return {
|
||
|
|
"objective": objective,
|
||
|
|
"approach": "Fallback plan - manual implementation",
|
||
|
|
"tasks": [
|
||
|
|
{
|
||
|
|
"id": "task_001",
|
||
|
|
"description": f"Implement: {objective}",
|
||
|
|
"file": "TBD",
|
||
|
|
"priority": "high",
|
||
|
|
}
|
||
|
|
],
|
||
|
|
"test_scenarios": [],
|
||
|
|
"acceptance_criteria": [objective],
|
||
|
|
}
|
||
|
|
|
||
|
|
async def analyze(self, test_results: Dict) -> Dict:
|
||
|
|
"""
|
||
|
|
Analyze test results using Gemini via OpenCode.
|
||
|
|
|
||
|
|
Args:
|
||
|
|
test_results: Test report from dashboard
|
||
|
|
|
||
|
|
Returns:
|
||
|
|
Analysis with issues and fix plans
|
||
|
|
"""
|
||
|
|
summary = test_results.get("summary", {})
|
||
|
|
scenarios = test_results.get("scenarios", [])
|
||
|
|
|
||
|
|
if summary.get("failed", 0) == 0:
|
||
|
|
return {
|
||
|
|
"issues_found": False,
|
||
|
|
"issues": [],
|
||
|
|
"fix_plans": {},
|
||
|
|
"recommendations": ["All tests passed!"],
|
||
|
|
}
|
||
|
|
|
||
|
|
failures = [s for s in scenarios if not s.get("passed", True)]
|
||
|
|
|
||
|
|
prompt = f"""Analyze these test failures for Atomizer FEA optimization framework:
|
||
|
|
|
||
|
|
## Test Summary
|
||
|
|
- Total: {summary.get("total", 0)}
|
||
|
|
- Passed: {summary.get("passed", 0)}
|
||
|
|
- Failed: {summary.get("failed", 0)}
|
||
|
|
|
||
|
|
## Failed Tests
|
||
|
|
{json.dumps(failures, indent=2)}
|
||
|
|
|
||
|
|
## Task
|
||
|
|
Provide root cause analysis and fix plans in JSON:
|
||
|
|
|
||
|
|
```json
|
||
|
|
{{
|
||
|
|
"issues_found": true,
|
||
|
|
"issues": [
|
||
|
|
{{
|
||
|
|
"id": "issue_001",
|
||
|
|
"description": "What went wrong",
|
||
|
|
"severity": "high",
|
||
|
|
"root_cause": "Why it failed"
|
||
|
|
}}
|
||
|
|
],
|
||
|
|
"fix_plans": {{
|
||
|
|
"issue_001": {{
|
||
|
|
"approach": "How to fix",
|
||
|
|
"steps": [{{"action": "edit", "file": "path", "description": "change"}}]
|
||
|
|
}}
|
||
|
|
}},
|
||
|
|
"recommendations": ["suggestion"]
|
||
|
|
}}
|
||
|
|
```
|
||
|
|
"""
|
||
|
|
|
||
|
|
result = await self.execute(prompt)
|
||
|
|
|
||
|
|
if not result.success:
|
||
|
|
return self._fallback_analysis(failures)
|
||
|
|
|
||
|
|
try:
|
||
|
|
output = result.output
|
||
|
|
if "```json" in output:
|
||
|
|
start = output.find("```json") + 7
|
||
|
|
end = output.find("```", start)
|
||
|
|
json_str = output[start:end].strip()
|
||
|
|
else:
|
||
|
|
match = re.search(r"\{.*\}", output, re.DOTALL)
|
||
|
|
json_str = match.group() if match else "{}"
|
||
|
|
|
||
|
|
return json.loads(json_str)
|
||
|
|
|
||
|
|
except:
|
||
|
|
return self._fallback_analysis(failures)
|
||
|
|
|
||
|
|
def _fallback_analysis(self, failures: List[Dict]) -> Dict:
|
||
|
|
"""Generate fallback analysis."""
|
||
|
|
issues = []
|
||
|
|
fix_plans = {}
|
||
|
|
|
||
|
|
for i, failure in enumerate(failures):
|
||
|
|
issue_id = f"issue_{i + 1}"
|
||
|
|
issues.append(
|
||
|
|
{
|
||
|
|
"id": issue_id,
|
||
|
|
"description": failure.get("error", "Unknown error"),
|
||
|
|
"severity": "medium",
|
||
|
|
"root_cause": "Requires investigation",
|
||
|
|
}
|
||
|
|
)
|
||
|
|
fix_plans[issue_id] = {
|
||
|
|
"approach": "Manual investigation required",
|
||
|
|
"steps": [],
|
||
|
|
}
|
||
|
|
|
||
|
|
return {
|
||
|
|
"issues_found": len(issues) > 0,
|
||
|
|
"issues": issues,
|
||
|
|
"fix_plans": fix_plans,
|
||
|
|
"recommendations": ["Review failed tests manually"],
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
class DevLoopCLIOrchestrator:
|
||
|
|
"""
|
||
|
|
Orchestrate DevLoop using CLI tools.
|
||
|
|
|
||
|
|
- OpenCode (Gemini) for planning and analysis
|
||
|
|
- Claude Code for implementation and fixes
|
||
|
|
"""
|
||
|
|
|
||
|
|
def __init__(self, workspace: Path = None):
|
||
|
|
self.workspace = workspace or Path("C:/Users/antoi/Atomizer")
|
||
|
|
self.claude = ClaudeCodeCLI(self.workspace)
|
||
|
|
self.opencode = OpenCodeCLI(self.workspace)
|
||
|
|
self.iteration = 0
|
||
|
|
|
||
|
|
async def run_cycle(
|
||
|
|
self,
|
||
|
|
objective: str,
|
||
|
|
context: Dict = None,
|
||
|
|
max_iterations: int = 5,
|
||
|
|
) -> Dict:
|
||
|
|
"""
|
||
|
|
Run a complete development cycle.
|
||
|
|
|
||
|
|
Args:
|
||
|
|
objective: What to achieve
|
||
|
|
context: Additional context
|
||
|
|
max_iterations: Maximum fix iterations
|
||
|
|
|
||
|
|
Returns:
|
||
|
|
Cycle report
|
||
|
|
"""
|
||
|
|
from .test_runner import DashboardTestRunner
|
||
|
|
|
||
|
|
start_time = datetime.now()
|
||
|
|
results = {
|
||
|
|
"objective": objective,
|
||
|
|
"iterations": [],
|
||
|
|
"status": "in_progress",
|
||
|
|
}
|
||
|
|
|
||
|
|
logger.info(f"Starting DevLoop cycle: {objective}")
|
||
|
|
|
||
|
|
# Phase 1: Plan (Gemini via OpenCode)
|
||
|
|
logger.info("Phase 1: Planning with Gemini...")
|
||
|
|
plan = await self.opencode.plan(objective, context)
|
||
|
|
|
||
|
|
iteration = 0
|
||
|
|
while iteration < max_iterations:
|
||
|
|
iteration += 1
|
||
|
|
iter_result = {"iteration": iteration}
|
||
|
|
|
||
|
|
# Phase 2: Implement (Claude Code)
|
||
|
|
logger.info(f"Phase 2 (iter {iteration}): Implementing with Claude Code...")
|
||
|
|
impl_result = await self._implement(plan)
|
||
|
|
iter_result["implementation"] = {
|
||
|
|
"success": impl_result.success,
|
||
|
|
"files_modified": impl_result.files_modified,
|
||
|
|
}
|
||
|
|
|
||
|
|
# Phase 3: Test (Dashboard)
|
||
|
|
logger.info(f"Phase 3 (iter {iteration}): Testing...")
|
||
|
|
test_runner = DashboardTestRunner()
|
||
|
|
test_results = await test_runner.run_test_suite(plan.get("test_scenarios", []))
|
||
|
|
iter_result["test_results"] = test_results
|
||
|
|
|
||
|
|
# Check if all tests pass
|
||
|
|
summary = test_results.get("summary", {})
|
||
|
|
if summary.get("failed", 0) == 0:
|
||
|
|
logger.info("All tests passed!")
|
||
|
|
results["iterations"].append(iter_result)
|
||
|
|
results["status"] = "success"
|
||
|
|
break
|
||
|
|
|
||
|
|
# Phase 4: Analyze (Gemini via OpenCode)
|
||
|
|
logger.info(f"Phase 4 (iter {iteration}): Analyzing failures...")
|
||
|
|
analysis = await self.opencode.analyze(test_results)
|
||
|
|
iter_result["analysis"] = analysis
|
||
|
|
|
||
|
|
if not analysis.get("issues_found"):
|
||
|
|
results["status"] = "success"
|
||
|
|
results["iterations"].append(iter_result)
|
||
|
|
break
|
||
|
|
|
||
|
|
# Phase 5: Fix (Claude Code)
|
||
|
|
logger.info(f"Phase 5 (iter {iteration}): Fixing issues...")
|
||
|
|
fix_result = await self._fix(analysis)
|
||
|
|
iter_result["fixes"] = {
|
||
|
|
"success": fix_result.success,
|
||
|
|
"files_modified": fix_result.files_modified,
|
||
|
|
}
|
||
|
|
|
||
|
|
results["iterations"].append(iter_result)
|
||
|
|
|
||
|
|
if results["status"] == "in_progress":
|
||
|
|
results["status"] = "max_iterations_reached"
|
||
|
|
|
||
|
|
results["duration_seconds"] = (datetime.now() - start_time).total_seconds()
|
||
|
|
|
||
|
|
logger.info(f"DevLoop cycle completed: {results['status']}")
|
||
|
|
|
||
|
|
return results
|
||
|
|
|
||
|
|
async def _implement(self, plan: Dict) -> CLIResult:
|
||
|
|
"""Implement the plan using Claude Code."""
|
||
|
|
tasks = plan.get("tasks", [])
|
||
|
|
|
||
|
|
if not tasks:
|
||
|
|
return CLIResult(
|
||
|
|
success=True,
|
||
|
|
output="No tasks to implement",
|
||
|
|
error="",
|
||
|
|
duration_seconds=0,
|
||
|
|
files_modified=[],
|
||
|
|
)
|
||
|
|
|
||
|
|
# Build implementation prompt
|
||
|
|
prompt = f"""Implement the following tasks for Atomizer:
|
||
|
|
|
||
|
|
## Objective
|
||
|
|
{plan.get("objective", "Unknown")}
|
||
|
|
|
||
|
|
## Approach
|
||
|
|
{plan.get("approach", "Follow best practices")}
|
||
|
|
|
||
|
|
## Tasks
|
||
|
|
"""
|
||
|
|
for task in tasks:
|
||
|
|
prompt += f"""
|
||
|
|
### {task.get("id", "task")}: {task.get("description", "")}
|
||
|
|
- File: {task.get("file", "TBD")}
|
||
|
|
- Priority: {task.get("priority", "medium")}
|
||
|
|
"""
|
||
|
|
|
||
|
|
prompt += """
|
||
|
|
## Requirements
|
||
|
|
- Follow Atomizer coding standards
|
||
|
|
- Use AtomizerSpec v2.0 format
|
||
|
|
- Create README.md for any new study
|
||
|
|
- Use existing extractors from optimization_engine/extractors/
|
||
|
|
"""
|
||
|
|
|
||
|
|
return await self.claude.execute(prompt, timeout=300)
|
||
|
|
|
||
|
|
async def _fix(self, analysis: Dict) -> CLIResult:
|
||
|
|
"""Apply fixes using Claude Code."""
|
||
|
|
issues = analysis.get("issues", [])
|
||
|
|
fix_plans = analysis.get("fix_plans", {})
|
||
|
|
|
||
|
|
if not issues:
|
||
|
|
return CLIResult(
|
||
|
|
success=True,
|
||
|
|
output="No issues to fix",
|
||
|
|
error="",
|
||
|
|
duration_seconds=0,
|
||
|
|
files_modified=[],
|
||
|
|
)
|
||
|
|
|
||
|
|
# Build fix prompt
|
||
|
|
prompt = "Fix the following issues:\n\n"
|
||
|
|
|
||
|
|
for issue in issues:
|
||
|
|
issue_id = issue.get("id", "unknown")
|
||
|
|
prompt += f"""
|
||
|
|
## Issue: {issue_id}
|
||
|
|
- Description: {issue.get("description", "")}
|
||
|
|
- Root Cause: {issue.get("root_cause", "Unknown")}
|
||
|
|
- Severity: {issue.get("severity", "medium")}
|
||
|
|
"""
|
||
|
|
|
||
|
|
fix_plan = fix_plans.get(issue_id, {})
|
||
|
|
if fix_plan:
|
||
|
|
prompt += f"- Fix Approach: {fix_plan.get('approach', 'Investigate')}\n"
|
||
|
|
for step in fix_plan.get("steps", []):
|
||
|
|
prompt += f" - {step.get('description', step.get('action', 'step'))}\n"
|
||
|
|
|
||
|
|
return await self.claude.execute(prompt, timeout=300)
|
||
|
|
|
||
|
|
async def step_plan(self, objective: str, context: Dict = None) -> Dict:
|
||
|
|
"""Execute only the planning phase."""
|
||
|
|
return await self.opencode.plan(objective, context)
|
||
|
|
|
||
|
|
async def step_implement(self, plan: Dict) -> CLIResult:
|
||
|
|
"""Execute only the implementation phase."""
|
||
|
|
return await self._implement(plan)
|
||
|
|
|
||
|
|
async def step_analyze(self, test_results: Dict) -> Dict:
|
||
|
|
"""Execute only the analysis phase."""
|
||
|
|
return await self.opencode.analyze(test_results)
|