Antoine/Atomizer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: Complete Phase 2.5-2.7 - Intelligent LLM-Powered Workflow Analysis

Browse Source 
This commit implements three major architectural improvements to transform
Atomizer from static pattern matching to intelligent AI-powered analysis.

## Phase 2.5: Intelligent Codebase-Aware Gap Detection ✅

Created intelligent system that understands existing capabilities before
requesting examples:

**New Files:**
- optimization_engine/codebase_analyzer.py (379 lines)
  Scans Atomizer codebase for existing FEA/CAE capabilities

- optimization_engine/workflow_decomposer.py (507 lines, v0.2.0)
  Breaks user requests into atomic workflow steps
  Complete rewrite with multi-objective, constraints, subcase targeting

- optimization_engine/capability_matcher.py (312 lines)
  Matches workflow steps to existing code implementations

- optimization_engine/targeted_research_planner.py (259 lines)
  Creates focused research plans for only missing capabilities

**Results:**
- 80-90% coverage on complex optimization requests
- 87-93% confidence in capability matching
- Fixed expression reading misclassification (geometry vs result_extraction)

## Phase 2.6: Intelligent Step Classification ✅

Distinguishes engineering features from simple math operations:

**New Files:**
- optimization_engine/step_classifier.py (335 lines)

**Classification Types:**
1. Engineering Features - Complex FEA/CAE needing research
2. Inline Calculations - Simple math to auto-generate
3. Post-Processing Hooks - Middleware between FEA steps

## Phase 2.7: LLM-Powered Workflow Intelligence ✅

Replaces static regex patterns with Claude AI analysis:

**New Files:**
- optimization_engine/llm_workflow_analyzer.py (395 lines)
  Uses Claude API for intelligent request analysis
  Supports both Claude Code (dev) and API (production) modes

- .claude/skills/analyze-workflow.md
  Skill template for LLM workflow analysis integration

**Key Breakthrough:**
- Detects ALL intermediate steps (avg, min, normalization, etc.)
- Understands engineering context (CBUSH vs CBAR, directions, metrics)
- Distinguishes OP2 extraction from part expression reading
- Expected 95%+ accuracy with full nuance detection

## Test Coverage

**New Test Files:**
- tests/test_phase_2_5_intelligent_gap_detection.py (335 lines)
- tests/test_complex_multiobj_request.py (130 lines)
- tests/test_cbush_optimization.py (130 lines)
- tests/test_cbar_genetic_algorithm.py (150 lines)
- tests/test_step_classifier.py (140 lines)
- tests/test_llm_complex_request.py (387 lines)

All tests include:
- UTF-8 encoding for Windows console
- atomizer environment (not test_env)
- Comprehensive validation checks

## Documentation

**New Documentation:**
- docs/PHASE_2_5_INTELLIGENT_GAP_DETECTION.md (254 lines)
- docs/PHASE_2_7_LLM_INTEGRATION.md (227 lines)
- docs/SESSION_SUMMARY_PHASE_2_5_TO_2_7.md (252 lines)

**Updated:**
- README.md - Added Phase 2.5-2.7 completion status
- DEVELOPMENT_ROADMAP.md - Updated phase progress

## Critical Fixes

1. **Expression Reading Misclassification** (lines cited in session summary)
   - Updated codebase_analyzer.py pattern detection
   - Fixed workflow_decomposer.py domain classification
   - Added capability_matcher.py read_expression mapping

2. **Environment Standardization**
   - All code now uses 'atomizer' conda environment
   - Removed test_env references throughout

3. **Multi-Objective Support**
   - WorkflowDecomposer v0.2.0 handles multiple objectives
   - Constraint extraction and validation
   - Subcase and direction targeting

## Architecture Evolution

**Before (Static & Dumb):**
User Request → Regex Patterns → Hardcoded Rules → Missed Steps ❌

**After (LLM-Powered & Intelligent):**
User Request → Claude AI Analysis → Structured JSON →
├─ Engineering (research needed)
├─ Inline (auto-generate Python)
├─ Hooks (middleware scripts)
└─ Optimization (config) ✅

## LLM Integration Strategy

**Development Mode (Current):**
- Use Claude Code directly for interactive analysis
- No API consumption or costs
- Perfect for iterative development

**Production Mode (Future):**
- Optional Anthropic API integration
- Falls back to heuristics if no API key
- For standalone batch processing

## Next Steps

- Phase 2.8: Inline Code Generation
- Phase 2.9: Post-Processing Hook Generation
- Phase 3: MCP Integration for automated documentation research

🚀 Generated with Claude Code

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
Anto01
2025-11-16 13:35:41 -05:00
parent 986285d9cf
commit 0a7cca9c6a
94 changed files with 12761 additions and 10670 deletions
Download Patch File Download Diff File Expand all files Collapse all files

74
optimization_engine/plugins/post_extraction/log_results.py Normal file
View File

@@ -0,0 +1,74 @@
"""
Post-Extraction Logger Plugin
Appends extracted results and final trial status to the log.
"""
from typing import Dict, Any, Optional
from pathlib import Path
from datetime import datetime
import logging
logger = logging.getLogger(__name__)
def log_extracted_results(context: Dict[str, Any]) -> Optional[Dict[str, Any]]:
"""
Log extracted results to the trial log file.
Args:
context: Hook context containing:
- trial_number: Current trial number
- design_variables: Dict of variable values
- extracted_results: Dict of all extracted objectives and constraints
- result_path: Path to result file
- working_dir: Current working directory
"""
trial_num = context.get('trial_number', '?')
extracted_results = context.get('extracted_results', {})
result_path = context.get('result_path', '')
# Get the output directory from context (passed by runner)
output_dir = Path(context.get('output_dir', 'optimization_results'))
log_dir = output_dir / 'trial_logs'
if not log_dir.exists():
logger.warning(f"Log directory not found: {log_dir}")
return None
# Find trial log file
log_files = list(log_dir.glob(f'trial_{trial_num:03d}_*.log'))
if not log_files:
logger.warning(f"No log file found for trial {trial_num}")
return None
# Use most recent log file
log_file = sorted(log_files)[-1]
with open(log_file, 'a') as f:
f.write(f"[{datetime.now().strftime('%H:%M:%S')}] POST_EXTRACTION: Results extracted\n")
f.write("\n")
f.write("-" * 80 + "\n")
f.write("EXTRACTED RESULTS\n")
f.write("-" * 80 + "\n")
for result_name, result_value in extracted_results.items():
f.write(f" {result_name:30s} = {result_value:12.4f}\n")
f.write("\n")
f.write(f"[{datetime.now().strftime('%H:%M:%S')}] Evaluating constraints...\n")
f.write(f"[{datetime.now().strftime('%H:%M:%S')}] Calculating total objective...\n")
f.write("\n")
return {'logged': True}
def register_hooks(hook_manager):
"""Register this plugin's hooks with the manager."""
hook_manager.register_hook(
hook_point='post_extraction',
function=log_extracted_results,
description='Log extracted results to trial log',
name='log_extracted_results',
priority=10
)

78
optimization_engine/plugins/post_extraction/optimization_logger_results.py Normal file
View File

@@ -0,0 +1,78 @@
"""
Optimization-Level Logger Hook - Results
Appends trial results to the high-level optimization.log file.
Hook Point: post_extraction
"""
from pathlib import Path
from datetime import datetime
from typing import Dict, Any, Optional
import logging
logger = logging.getLogger(__name__)
def log_optimization_results(context: Dict[str, Any]) -> Optional[Dict[str, Any]]:
"""
Append trial results to the main optimization.log file.
This hook completes the trial entry in the high-level log with:
- Objective values
- Constraint evaluations
- Trial outcome (feasible/infeasible)
Args:
context: Hook context containing:
- trial_number: Current trial number
- extracted_results: Dict of all extracted objectives and constraints
- result_path: Path to result file
Returns:
None (logging only)
"""
trial_num = context.get('trial_number', '?')
extracted_results = context.get('extracted_results', {})
result_path = context.get('result_path', '')
# Get the output directory from context (passed by runner)
output_dir = Path(context.get('output_dir', 'optimization_results'))
log_file = output_dir / 'optimization.log'
if not log_file.exists():
logger.warning(f"Optimization log file not found: {log_file}")
return None
# Find the last line for this trial and append results
with open(log_file, 'a') as f:
timestamp = datetime.now().strftime('%H:%M:%S')
# Extract objective and constraint values
results_str = " | ".join([f"{name}={value:.3f}" for name, value in extracted_results.items()])
f.write(f"[{timestamp}] Trial {trial_num:3d} COMPLETE | {results_str}\n")
return None
def register_hooks(hook_manager):
"""
Register this plugin's hooks with the manager.
This function is called automatically when the plugin is loaded.
"""
hook_manager.register_hook(
hook_point='post_extraction',
function=log_optimization_results,
description='Append trial results to optimization.log',
name='optimization_logger_results',
priority=100
)
# Hook metadata
HOOK_NAME = "optimization_logger_results"
HOOK_POINT = "post_extraction"
ENABLED = True
PRIORITY = 100

63
optimization_engine/plugins/post_solve/log_solve_complete.py Normal file
View File

@@ -0,0 +1,63 @@
"""
Post-Solve Logger Plugin
Appends solver completion information to the trial log.
"""
from typing import Dict, Any, Optional
from pathlib import Path
from datetime import datetime
import logging
logger = logging.getLogger(__name__)
def log_solve_complete(context: Dict[str, Any]) -> Optional[Dict[str, Any]]:
"""
Log solver completion information to the trial log file.
Args:
context: Hook context containing:
- trial_number: Current trial number
- design_variables: Dict of variable values
- result_path: Path to OP2 result file
- working_dir: Current working directory
"""
trial_num = context.get('trial_number', '?')
result_path = context.get('result_path', 'unknown')
# Get the output directory from context (passed by runner)
output_dir = Path(context.get('output_dir', 'optimization_results'))
log_dir = output_dir / 'trial_logs'
if not log_dir.exists():
logger.warning(f"Log directory not found: {log_dir}")
return None
# Find trial log file
log_files = list(log_dir.glob(f'trial_{trial_num:03d}_*.log'))
if not log_files:
logger.warning(f"No log file found for trial {trial_num}")
return None
# Use most recent log file
log_file = sorted(log_files)[-1]
with open(log_file, 'a') as f:
f.write(f"[{datetime.now().strftime('%H:%M:%S')}] POST_SOLVE: Simulation complete\n")
f.write(f"[{datetime.now().strftime('%H:%M:%S')}] Result file: {Path(result_path).name}\n")
f.write(f"[{datetime.now().strftime('%H:%M:%S')}] Result path: {result_path}\n")
f.write(f"[{datetime.now().strftime('%H:%M:%S')}] Waiting for result extraction...\n")
f.write("\n")
return {'logged': True}
def register_hooks(hook_manager):
"""Register this plugin's hooks with the manager."""
hook_manager.register_hook(
hook_point='post_solve',
function=log_solve_complete,
description='Log solver completion to trial log',
name='log_solve_complete',
priority=10
)

125
optimization_engine/plugins/pre_solve/detailed_logger.py Normal file
View File

@@ -0,0 +1,125 @@
"""
Detailed Logger Plugin
Logs comprehensive information about each optimization iteration to a file.
Creates a detailed trace of all steps for debugging and analysis.
"""
from typing import Dict, Any, Optional
from pathlib import Path
from datetime import datetime
import json
import logging
logger = logging.getLogger(__name__)
def detailed_iteration_logger(context: Dict[str, Any]) -> Optional[Dict[str, Any]]:
"""
Log detailed information about the current trial to a timestamped log file.
Args:
context: Hook context containing:
- trial_number: Current trial number
- design_variables: Dict of variable values
- sim_file: Path to simulation file
- working_dir: Current working directory
- config: Full optimization configuration
Returns:
Dict with log file path
"""
trial_num = context.get('trial_number', '?')
design_vars = context.get('design_variables', {})
sim_file = context.get('sim_file', 'unknown')
config = context.get('config', {})
# Get the output directory from context (passed by runner)
output_dir = Path(context.get('output_dir', 'optimization_results'))
# Create logs subdirectory within the study results
log_dir = output_dir / 'trial_logs'
log_dir.mkdir(parents=True, exist_ok=True)
# Create trial-specific log file
timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
log_file = log_dir / f'trial_{trial_num:03d}_{timestamp}.log'
with open(log_file, 'w') as f:
f.write("=" * 80 + "\n")
f.write(f"OPTIMIZATION ITERATION LOG - Trial {trial_num}\n")
f.write("=" * 80 + "\n")
f.write(f"Timestamp: {datetime.now().isoformat()}\n")
f.write(f"Output Directory: {output_dir}\n")
f.write(f"Simulation File: {sim_file}\n")
f.write("\n")
f.write("-" * 80 + "\n")
f.write("DESIGN VARIABLES\n")
f.write("-" * 80 + "\n")
for var_name, var_value in design_vars.items():
f.write(f" {var_name:30s} = {var_value:12.4f}\n")
f.write("\n")
f.write("-" * 80 + "\n")
f.write("OPTIMIZATION CONFIGURATION\n")
f.write("-" * 80 + "\n")
config = context.get('config', {})
# Objectives
f.write("\nObjectives:\n")
for obj in config.get('objectives', []):
f.write(f" - {obj['name']}: {obj['direction']} (weight={obj.get('weight', 1.0)})\n")
# Constraints
constraints = config.get('constraints', [])
if constraints:
f.write("\nConstraints:\n")
for const in constraints:
f.write(f" - {const['name']}: {const['type']} limit={const['limit']} {const.get('units', '')}\n")
# Settings
settings = config.get('optimization_settings', {})
f.write("\nOptimization Settings:\n")
f.write(f" Sampler: {settings.get('sampler', 'unknown')}\n")
f.write(f" Total trials: {settings.get('n_trials', '?')}\n")
f.write(f" Startup trials: {settings.get('n_startup_trials', '?')}\n")
f.write("\n")
f.write("-" * 80 + "\n")
f.write("EXECUTION TIMELINE\n")
f.write("-" * 80 + "\n")
f.write(f"[{datetime.now().strftime('%H:%M:%S')}] PRE_SOLVE: Trial {trial_num} starting\n")
f.write(f"[{datetime.now().strftime('%H:%M:%S')}] Design variables prepared\n")
f.write(f"[{datetime.now().strftime('%H:%M:%S')}] Waiting for model update...\n")
f.write("\n")
f.write("-" * 80 + "\n")
f.write("NOTES\n")
f.write("-" * 80 + "\n")
f.write("This log will be updated by subsequent hooks during the optimization.\n")
f.write("Check post_solve and post_extraction logs for complete results.\n")
f.write("\n")
logger.info(f"Trial {trial_num} log created: {log_file}")
return {
'log_file': str(log_file),
'trial_number': trial_num,
'logged': True
}
def register_hooks(hook_manager):
"""
Register this plugin's hooks with the manager.
This function is called automatically when the plugin is loaded.
"""
hook_manager.register_hook(
hook_point='pre_solve',
function=detailed_iteration_logger,
description='Create detailed log file for each trial',
name='detailed_logger',
priority=5 # Run very early to capture everything
)

129
optimization_engine/plugins/pre_solve/optimization_logger.py Normal file
View File

@@ -0,0 +1,129 @@
"""
Optimization-Level Logger Hook
Creates a high-level optimization log file that tracks the overall progress
across all trials. This complements the detailed per-trial logs.
Hook Point: pre_solve
"""
from pathlib import Path
from datetime import datetime
from typing import Dict, Any, Optional
import logging
logger = logging.getLogger(__name__)
def log_optimization_progress(context: Dict[str, Any]) -> Optional[Dict[str, Any]]:
"""
Log high-level optimization progress to optimization.log.
This hook creates/appends to a main optimization log file that shows:
- Trial start with design variables
- High-level progress tracking
- Easy-to-scan overview of the optimization run
Args:
context: Hook context containing:
- trial_number: Current trial number
- design_variables: Dict of variable values
- sim_file: Path to simulation file
- config: Full optimization configuration
Returns:
None (logging only)
"""
trial_num = context.get('trial_number', '?')
design_vars = context.get('design_variables', {})
sim_file = context.get('sim_file', 'unknown')
config = context.get('config', {})
# Get the output directory from context (passed by runner)
output_dir = Path(context.get('output_dir', 'optimization_results'))
# Main optimization log file
log_file = output_dir / 'optimization.log'
# Create header on first trial
if trial_num == 0:
output_dir.mkdir(parents=True, exist_ok=True)
with open(log_file, 'w') as f:
f.write("=" * 100 + "\n")
f.write(f"OPTIMIZATION RUN - Started {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
f.write("=" * 100 + "\n")
f.write(f"Simulation File: {sim_file}\n")
f.write(f"Output Directory: {output_dir}\n")
# Optimization settings
opt_settings = config.get('optimization_settings', {})
f.write(f"\nOptimization Settings:\n")
f.write(f" Total Trials: {opt_settings.get('n_trials', 'unknown')}\n")
f.write(f" Sampler: {opt_settings.get('sampler', 'unknown')}\n")
f.write(f" Startup Trials: {opt_settings.get('n_startup_trials', 'unknown')}\n")
# Design variables
design_vars_config = config.get('design_variables', [])
f.write(f"\nDesign Variables:\n")
for dv in design_vars_config:
name = dv.get('name', 'unknown')
bounds = dv.get('bounds', [])
units = dv.get('units', '')
f.write(f" {name}: {bounds[0]:.2f} - {bounds[1]:.2f} {units}\n")
# Objectives
objectives = config.get('objectives', [])
f.write(f"\nObjectives:\n")
for obj in objectives:
name = obj.get('name', 'unknown')
direction = obj.get('direction', 'unknown')
units = obj.get('units', '')
f.write(f" {name} ({direction}) [{units}]\n")
# Constraints
constraints = config.get('constraints', [])
if constraints:
f.write(f"\nConstraints:\n")
for cons in constraints:
name = cons.get('name', 'unknown')
cons_type = cons.get('type', 'unknown')
limit = cons.get('limit', 'unknown')
units = cons.get('units', '')
f.write(f" {name}: {cons_type} {limit} {units}\n")
f.write("\n" + "=" * 100 + "\n")
f.write("TRIAL PROGRESS\n")
f.write("=" * 100 + "\n\n")
# Append trial start
with open(log_file, 'a') as f:
timestamp = datetime.now().strftime('%H:%M:%S')
f.write(f"[{timestamp}] Trial {trial_num:3d} START | ")
# Write design variables in compact format
dv_str = ", ".join([f"{name}={value:.3f}" for name, value in design_vars.items()])
f.write(f"{dv_str}\n")
return None
def register_hooks(hook_manager):
"""
Register this plugin's hooks with the manager.
This function is called automatically when the plugin is loaded.
"""
hook_manager.register_hook(
hook_point='pre_solve',
function=log_optimization_progress,
description='Create high-level optimization.log file',
name='optimization_logger',
priority=100 # Run early to set up log file
)
# Hook metadata
HOOK_NAME = "optimization_logger"
HOOK_POINT = "pre_solve"
ENABLED = True
PRIORITY = 100 # Run early to set up log file