refactoring, code comment bug, remove go types and handle them in go config, simplify core

Author: MS-32154

.gitignore

@@ -4,5 +4,6 @@ venv/
 __pycache__/
 *.egg-info/
 notes/
+generated_examples/
 
 codegen_*_test.py

json_explorer/codegen/__init__.py

@@ -4,103 +4,173 @@
 Generates code in various languages from JSON schema analysis.
 """
 
-from .registry import GeneratorRegistry, get_generator, list_supported_languages
-from .core.generator import CodeGenerator, GenerationResult, generate_code
-from .core.schema import (
+from .registry import (
+    GeneratorRegistry,
+    get_generator,
+    list_supported_languages,
+    register_generator,
+    get_language_info,
+)
+from .core import (
+    CodeGenerator,
+    GeneratorError,
+    GenerationResult,
+    generate_code,
     Schema,
     Field,
     FieldType,
     convert_analyzer_output,
     extract_all_schemas,
+    GeneratorConfig,
+    load_config,
+    NameSanitizer,
+    NamingCase,
+    TemplateEngine,
+    TemplateError,
+    create_template_engine,
 )
-from .core.config import GeneratorConfig, ConfigManager, load_config
 
-# Initialize registry with available generators
+# Initialize global registry
 registry = GeneratorRegistry()
 
+
 # Auto-register available generators
-try:
-    from .languages.go.generator import GoGenerator
+def _register_available_generators():
+    """Register all available language generators."""
+    try:
+        from .languages.go import GoGenerator
+
+        registry.register("go", GoGenerator, aliases=["golang"])
+    except ImportError:
+        pass
 
-    registry.register("go", GoGenerator)
-except ImportError:
-    pass
+    # Add more languages here as they become available
+    # try:
+    #     from .languages.python import PythonGenerator
+    #     registry.register("python", PythonGenerator, aliases=["py"])
+    # except ImportError:
+    #     pass
+
+
+# Initialize registry
+_register_available_generators()
 
 # Version info
 __version__ = "0.1.0"
 
 
-# Convenience functions
 def generate_from_analysis(
     analyzer_result, language="go", config=None, root_name="Root"
-):
+) -> GenerationResult:
     """
     Generate code from analyzer output.
 
     Args:
         analyzer_result: Output from json_explorer.analyzer.analyze_json()
         language: Target language name
-        config: Generator configuration dict or path
+        config: GeneratorConfig instance, dict, or path to config file
         root_name: Name for root schema
 
     Returns:
-        GenerationResult with generated code
+        GenerationResult with generated code and metadata
     """
     # Convert analyzer result to schema
     root_schema = convert_analyzer_output(analyzer_result, root_name)
     all_schemas = extract_all_schemas(root_schema)
 
-    # Get generator
+    # Get generator instance
     generator = get_generator(language, config)
 
     # Generate code
     return generate_code(generator, all_schemas, root_name)
 
 
-def quick_generate(json_data, language="go", **options):
+def quick_generate(json_data, language="go", **options) -> str:
     """
     Quick code generation from JSON data.
 
     Args:
         json_data: JSON data (dict/list/str)
         language: Target language
-        **options: Generator options
+        **options: Generator configuration options
 
     Returns:
         Generated code string
+
+    Raises:
+        GeneratorError: If generation fails
     """
     from json_explorer.analyzer import analyze_json
+    import json as json_module
 
     # Convert string to dict if needed
     if isinstance(json_data, str):
-        import json
-
-        json_data = json.loads(json_data)
+        try:
+            json_data = json_module.loads(json_data)
+        except json_module.JSONDecodeError as e:
+            raise GeneratorError(f"Invalid JSON data: {e}")
 
     # Analyze JSON
-    analysis = analyze_json(json_data)
+    try:
+        analysis = analyze_json(json_data)
+    except Exception as e:
+        raise GeneratorError(f"JSON analysis failed: {e}")
 
     # Generate code
     result = generate_from_analysis(analysis, language, options)
 
     if result.success:
         return result.code
     else:
-        raise RuntimeError(f"Code generation failed: {result.error_message}")
+        raise GeneratorError(f"Code generation failed: {result.error_message}")
+
+
+def create_config(language="go", **kwargs) -> GeneratorConfig:
+    """
+    Create a GeneratorConfig for the specified language.
+
+    Args:
+        language: Target language
+        **kwargs: Configuration options
+
+    Returns:
+        GeneratorConfig instance
+    """
+    return load_config(custom_config=kwargs)
 
 
 # Export main interfaces
 __all__ = [
+    # Registry
     "GeneratorRegistry",
+    "get_generator",
+    "list_supported_languages",
+    "register_generator",
+    "registry",
+    "get_language_info",
+    # Core interfaces
     "CodeGenerator",
+    "GeneratorError",
     "GenerationResult",
+    "generate_code",
+    # Schema system
     "Schema",
     "Field",
     "FieldType",
+    "convert_analyzer_output",
+    "extract_all_schemas",
+    # Configuration
     "GeneratorConfig",
+    "load_config",
+    "create_config",
+    # Naming utilities
+    "NameSanitizer",
+    "NamingCase",
+    # Template system
+    "TemplateEngine",
+    "TemplateError",
+    "create_template_engine",
+    # High-level API
     "generate_from_analysis",
     "quick_generate",
-    "get_generator",
-    "list_supported_languages",
-    "registry",
 ]