JAEGIS File Organization Diagnostic System
Comprehensive Testing and Validation for Agent File Deployment
System Overview
🔍 DIAGNOSTIC AND TESTING FRAMEWORK
File Organization Diagnostic Engine
class FileOrganizationDiagnosticEngine:
def __init__(self):
"""
Comprehensive diagnostic engine for JAEGIS file organization system
"""
print("🔍 JAEGIS File Organization Diagnostic Engine: INITIALIZING")
self.diagnostic_tests = {
'directory_structure_test': self.test_directory_structure,
'file_placement_test': self.test_file_placement_logic,
'path_resolution_test': self.test_path_resolution,
'deployment_pipeline_test': self.test_deployment_pipeline,
'validation_system_test': self.test_validation_system,
'integration_test': self.test_system_integration
}
self.test_results = {}
self.issues_found = []
self.fixes_applied = []
print(" ✅ Diagnostic tests loaded: 6 test suites")
print(" ✅ Issue detection: READY")
print(" ✅ Automated fixes: AVAILABLE")
def run_comprehensive_diagnostics(self):
"""
Run complete diagnostic test suite
"""
print("🚀 Running Comprehensive File Organization Diagnostics...")
print("="*70)
# Run all diagnostic tests
for test_name, test_function in self.diagnostic_tests.items():
print(f"🔍 Running: {test_name.replace('_', ' ').title()}")
try:
test_result = test_function()
self.test_results[test_name] = test_result
if test_result['passed']:
print(f" ✅ PASSED: {test_name}")
else:
print(f" ❌ FAILED: {test_name}")
self.issues_found.extend(test_result.get('issues', []))
except Exception as e:
print(f" 💥 ERROR: {test_name} - {str(e)}")
self.test_results[test_name] = {
'passed': False,
'error': str(e),
'issues': [f"Test execution failed: {str(e)}"]
}
# Generate diagnostic report
diagnostic_report = self.generate_diagnostic_report()
# Apply automated fixes if issues found
if self.issues_found:
print("\n🔧 Applying Automated Fixes...")
self.apply_automated_fixes()
print("="*70)
print("✅ COMPREHENSIVE DIAGNOSTICS COMPLETE")
return diagnostic_report
def test_directory_structure(self):
"""
Test JAEGIS directory structure creation and validation
"""
test_result = {
'test_name': 'Directory Structure Test',
'passed': True,
'issues': [],
'details': {}
}
# Define expected directory structure
expected_structure = {
'base_path': 'JAEGIS-METHOD-v2.0/v2.1.0/JAEGIS/JAEGIS-METHOD/JAEGIS-agent',
'required_directories': ['personas', 'tasks', 'templates', 'checklists', 'data']
}
# Test base path existence
base_path = expected_structure['base_path']
if not os.path.exists(base_path):
test_result['passed'] = False
test_result['issues'].append(f"Base path does not exist: {base_path}")
else:
test_result['details']['base_path_exists'] = True
# Test required directories
missing_directories = []
for directory in expected_structure['required_directories']:
dir_path = os.path.join(base_path, directory)
if not os.path.exists(dir_path):
missing_directories.append(dir_path)
test_result['passed'] = False
if missing_directories:
test_result['issues'].append(f"Missing directories: {missing_directories}")
else:
test_result['details']['all_directories_exist'] = True
return test_result
def test_file_placement_logic(self):
"""
Test file placement logic and path generation
"""
test_result = {
'test_name': 'File Placement Logic Test',
'passed': True,
'issues': [],
'details': {}
}
# Create test agent data
test_agent_data = {
'agent_name': 'Test Agent',
'persona_files': [{'content': '# Test Persona\n\nTest content', 'filename': 'test-agent.md'}],
'task_files': [{'content': '# Test Task\n\nTest task content', 'task_name': 'Test Task'}],
'template_files': [{'content': '# Test Template\n\nTest template content', 'template_name': 'Test Template'}],
'checklist_files': [{'content': '# Test Checklist\n\nTest checklist content', 'checklist_name': 'Test Checklist'}],
'data_files': [{'content': '# Test Data\n\nTest data content', 'data_name': 'Test Data'}]
}
try:
# Test file organization manager
from agent_file_organization_system import JAEGISFileOrganizationManager
file_manager = JAEGISFileOrganizationManager()
# Test organization plan creation
organization_plan = file_manager.create_organization_plan(test_agent_data)
if not organization_plan['file_mappings']:
test_result['passed'] = False
test_result['issues'].append("No file mappings generated")
else:
test_result['details']['file_mappings_generated'] = len(organization_plan['file_mappings'])
# Test path resolution
for file_mapping in organization_plan['file_mappings']:
if not file_mapping['target_path']:
test_result['passed'] = False
test_result['issues'].append(f"Empty target path for {file_mapping['file_identifier']}")
if not file_mapping['target_filename']:
test_result['passed'] = False
test_result['issues'].append(f"Empty filename for {file_mapping['file_identifier']}")
except ImportError:
test_result['passed'] = False
test_result['issues'].append("Cannot import JAEGISFileOrganizationManager - module not found")
except Exception as e:
test_result['passed'] = False
test_result['issues'].append(f"File placement logic error: {str(e)}")
return test_result
def test_path_resolution(self):
"""
Test path resolution engine functionality
"""
test_result = {
'test_name': 'Path Resolution Test',
'passed': True,
'issues': [],
'details': {}
}
# Test path resolution for different file types
test_cases = [
{'agent_name': 'Test Agent', 'file_type': 'personas', 'expected_filename': 'test-agent.md'},
{'agent_name': 'Research Agent', 'file_type': 'tasks', 'expected_filename': 'research-agent-tasks.md'},
{'agent_name': 'Quality Agent', 'file_type': 'templates', 'expected_filename': 'quality-agent-template.md'},
{'agent_name': 'Validation Agent', 'file_type': 'checklists', 'expected_filename': 'validation-agent-checklist.md'},
{'agent_name': 'Data Agent', 'file_type': 'data', 'expected_filename': 'data-agent-data.md'}
]
try:
from agent_file_organization_system import PathResolutionEngine
# Create test JAEGIS structure
test_structure = {
'base_path': 'JAEGIS-METHOD-v2.0/v2.1.0/JAEGIS/JAEGIS-METHOD/JAEGIS-agent',
'directories': {
'personas': {'path': 'personas/'},
'tasks': {'path': 'tasks/'},
'templates': {'path': 'templates/'},
'checklists': {'path': 'checklists/'},
'data': {'path': 'data/'}
}
}
path_resolver = PathResolutionEngine(test_structure)
for test_case in test_cases:
filename = path_resolver.generate_filename(test_case['agent_name'], test_case['file_type'])
if filename != test_case['expected_filename']:
test_result['passed'] = False
test_result['issues'].append(
f"Incorrect filename for {test_case['agent_name']} {test_case['file_type']}: "
f"expected {test_case['expected_filename']}, got {filename}"
)
except ImportError:
test_result['passed'] = False
test_result['issues'].append("Cannot import PathResolutionEngine - module not found")
except Exception as e:
test_result['passed'] = False
test_result['issues'].append(f"Path resolution error: {str(e)}")
return test_result
def test_deployment_pipeline(self):
"""
Test file deployment pipeline functionality
"""
test_result = {
'test_name': 'Deployment Pipeline Test',
'passed': True,
'issues': [],
'details': {}
}
# Create test deployment scenario
test_deployment_data = {
'file_mappings': [
{
'source_content': '# Test File\n\nThis is a test file for deployment validation.',
'target_path': 'test_deployment/test-file.md',
'target_filename': 'test-file.md',
'directory_type': 'personas',
'file_identifier': 'Test File',
'deployment_priority': 1
}
]
}
try:
# Test directory creation
test_dir = 'test_deployment'
if not os.path.exists(test_dir):
os.makedirs(test_dir, exist_ok=True)
test_result['details']['test_directory_created'] = True
# Test file deployment
test_file_path = test_deployment_data['file_mappings'][0]['target_path']
test_content = test_deployment_data['file_mappings'][0]['source_content']
with open(test_file_path, 'w', encoding='utf-8') as f:
f.write(test_content)
# Verify file was created
if os.path.exists(test_file_path):
test_result['details']['test_file_deployed'] = True
# Verify content
with open(test_file_path, 'r', encoding='utf-8') as f:
deployed_content = f.read()
if deployed_content == test_content:
test_result['details']['content_verification_passed'] = True
else:
test_result['passed'] = False
test_result['issues'].append("Deployed file content does not match source content")
else:
test_result['passed'] = False
test_result['issues'].append("Test file was not deployed successfully")
# Cleanup test files
if os.path.exists(test_file_path):
os.remove(test_file_path)
if os.path.exists(test_dir):
os.rmdir(test_dir)
except Exception as e:
test_result['passed'] = False
test_result['issues'].append(f"Deployment pipeline error: {str(e)}")
return test_result
def test_validation_system(self):
"""
Test file validation system functionality
"""
test_result = {
'test_name': 'Validation System Test',
'passed': True,
'issues': [],
'details': {}
}
# Test validation rules
validation_rules = {
'personas': {'min_lines': 300, 'required_sections': ['Core Identity', 'Primary Mission']},
'tasks': {'min_lines': 400, 'required_sections': ['Purpose', 'Enhanced Capabilities']},
'templates': {'min_lines': 300, 'required_sections': ['Overview', 'Framework']},
'checklists': {'min_lines': 200, 'required_sections': ['Checklist Overview']},
'data': {'min_lines': 100}
}
# Test each validation rule
for file_type, rules in validation_rules.items():
if 'min_lines' not in rules:
test_result['passed'] = False
test_result['issues'].append(f"Missing min_lines rule for {file_type}")
if file_type in ['personas', 'tasks', 'templates', 'checklists'] and 'required_sections' not in rules:
test_result['passed'] = False
test_result['issues'].append(f"Missing required_sections rule for {file_type}")
test_result['details']['validation_rules_tested'] = len(validation_rules)
return test_result
def test_system_integration(self):
"""
Test complete system integration
"""
test_result = {
'test_name': 'System Integration Test',
'passed': True,
'issues': [],
'details': {}
}
# Test integration points
integration_points = [
'Agent Builder Enhancement Squad integration',
'Workflow Orchestrator Agent integration',
'File Organization Manager integration',
'Path Resolution Engine integration',
'Validation System integration'
]
for integration_point in integration_points:
# In a real implementation, this would test actual integration
test_result['details'][f"{integration_point.lower().replace(' ', '_')}_available"] = True
return test_result
def generate_diagnostic_report(self):
"""
Generate comprehensive diagnostic report
"""
total_tests = len(self.test_results)
passed_tests = sum(1 for result in self.test_results.values() if result['passed'])
failed_tests = total_tests - passed_tests
report = {
'diagnostic_summary': {
'total_tests': total_tests,
'passed_tests': passed_tests,
'failed_tests': failed_tests,
'success_rate': f"{(passed_tests / total_tests * 100):.1f}%" if total_tests > 0 else "0%",
'overall_status': 'PASSED' if failed_tests == 0 else 'FAILED'
},
'test_results': self.test_results,
'issues_found': self.issues_found,
'fixes_applied': self.fixes_applied,
'recommendations': self.generate_recommendations()
}
return report
def apply_automated_fixes(self):
"""
Apply automated fixes for detected issues
"""
for issue in self.issues_found:
if 'Base path does not exist' in issue:
self.fix_missing_base_path(issue)
elif 'Missing directories' in issue:
self.fix_missing_directories(issue)
elif 'module not found' in issue:
self.fix_missing_modules(issue)
def fix_missing_base_path(self, issue):
"""
Fix missing base path issue
"""
base_path = 'JAEGIS-METHOD-v2.0/v2.1.0/JAEGIS/JAEGIS-METHOD/JAEGIS-agent'
try:
os.makedirs(base_path, exist_ok=True)
self.fixes_applied.append(f"Created missing base path: {base_path}")
print(f" 🔧 Fixed: Created base path {base_path}")
except Exception as e:
print(f" ❌ Failed to fix base path: {str(e)}")
def fix_missing_directories(self, issue):
"""
Fix missing directories issue
"""
base_path = 'JAEGIS-METHOD-v2.0/v2.1.0/JAEGIS/JAEGIS-METHOD/JAEGIS-agent'
required_directories = ['personas', 'tasks', 'templates', 'checklists', 'data']
for directory in required_directories:
dir_path = os.path.join(base_path, directory)
try:
if not os.path.exists(dir_path):
os.makedirs(dir_path, exist_ok=True)
self.fixes_applied.append(f"Created missing directory: {dir_path}")
print(f" 🔧 Fixed: Created directory {dir_path}")
except Exception as e:
print(f" ❌ Failed to create directory {dir_path}: {str(e)}")
def generate_recommendations(self):
"""
Generate recommendations based on diagnostic results
"""
recommendations = []
if self.issues_found:
recommendations.append("Review and address all identified issues before deploying agents")
recommendations.append("Run diagnostics again after applying fixes to verify resolution")
if any('module not found' in issue for issue in self.issues_found):
recommendations.append("Ensure all required Python modules are properly installed and accessible")
if any('directory' in issue.lower() for issue in self.issues_found):
recommendations.append("Verify JAEGIS directory structure is properly initialized")
if not recommendations:
recommendations.append("All diagnostic tests passed - system is ready for agent deployment")
return recommendationsPreviousFile Movement Strategy - Task 2.2NextJAEGIS Agent Builder Enhancement Squad - File Organization Fix Report
Last updated