update codegen integration in main cli

Author: MS-32154

json_explorer/cli.py

@@ -5,8 +5,6 @@
 from .stats import DataStatsAnalyzer
 from .visualizer import JSONVisualizer
 from .filter_parser import FilterExpressionParser
-from .analyzer import analyze_json
-from .codegen import MultiTargetGenerator, parse_config_string
 
 
 class CLIHandler:
@@ -28,7 +26,7 @@ def set_data(self, data, source):
     def run(self, args):
         """Run CLI mode operations based on arguments."""
         if not self.data:
-            self.console.print("⌛ [red]No data loaded[/red]")
+            self.console.print("❌ [red]No data loaded[/red]")
             return 1
 
         self.console.print(f"📄 Loaded: {self.source}")
@@ -49,9 +47,8 @@ def run(self, args):
         if args.plot:
             self._handle_visualization(args)
 
-        # Code generation
-        if args.codegen:
-            self._handle_codegen(args)
+        # Note: Code generation is handled by main.py -> handle_codegen_command()
+        # This keeps the CLI focused on core analysis features
 
         return 0
 
@@ -86,7 +83,7 @@ def _handle_search(self, args):
         elif args.search_type == "pair":
             if not args.search_value:
                 self.console.print(
-                    "⌛ [red]--search-value required for pair search[/red]"
+                    "❌ [red]--search-value required for pair search[/red]"
                 )
                 return
             results = self.searcher.search_key_value_pairs(
@@ -97,10 +94,10 @@ def _handle_search(self, args):
                 filter_func = FilterExpressionParser.parse_filter(search_term)
                 results = self.searcher.search_with_filter(self.data, filter_func)
             except Exception as e:
-                self.console.print(f"⌛ [red]Filter error: {e}[/red]")
+                self.console.print(f"❌ [red]Filter error: {e}[/red]")
                 return
         else:
-            self.console.print(f"⌛ [red]Unknown search type: {args.search_type}[/red]")
+            self.console.print(f"❌ [red]Unknown search type: {args.search_type}[/red]")
             return
 
         # Display results
@@ -140,72 +137,4 @@ def _handle_visualization(self, args):
                 "✅ [green]Visualizations generated successfully[/green]"
             )
         except Exception as e:
-            self.console.print(f"⌛ [red]Visualization error: {e}[/red]")
-
-    def _handle_codegen(self, args):
-        """Handle code generation."""
-        self.console.print("\n🔧 Generating code from JSON schema...")
-
-        try:
-            # Analyze JSON to generate schema
-            schema = analyze_json(self.data)
-
-            # Create generator
-            root_name = getattr(args, "codegen_root", "Root")
-            generator = MultiTargetGenerator(schema, root_name=root_name)
-
-            # Parse configuration if provided
-            config_dict = {}
-            if hasattr(args, "codegen_config") and args.codegen_config:
-                config_dict = parse_config_string(args.codegen_config)
-
-            # Handle target selection
-            if args.codegen == "all":
-                # Generate all targets
-                self.console.print("📝 Generating code for all supported targets...")
-                results = generator.generate_all(config_dict)
-
-                for target, code in results.items():
-                    self.console.print(f"\n{'='*60}")
-                    self.console.print(
-                        f"🎯 [bold cyan]TARGET: {target.upper()}[/bold cyan]"
-                    )
-                    self.console.print("=" * 60)
-                    print(code)
-
-                self.console.print(
-                    f"\n✅ [green]Generated code for {len(results)} targets[/green]"
-                )
-
-            elif args.codegen in generator.list_targets():
-                # Generate specific target
-                self.console.print(f"📝 Generating {args.codegen.upper()} code...")
-                code = generator.generate(args.codegen, config_dict)
-
-                self.console.print(
-                    f"\n🎯 [bold cyan]{args.codegen.upper()} Code:[/bold cyan]"
-                )
-                self.console.print("-" * 50)
-                print(code)
-
-                self.console.print(f"\n✅ [green]Code generated successfully[/green]")
-
-            else:
-                available = ", ".join(generator.list_targets())
-                self.console.print(f"⌛ [red]Unknown target: {args.codegen}[/red]")
-                self.console.print(
-                    f"[yellow]Available targets: {available}, all[/yellow]"
-                )
-
-        except Exception as e:
-            self.console.print(f"⌛ [red]Code generation error: {e}[/red]")
-
-    def list_codegen_targets(self):
-        """List available code generation targets."""
-        generator = MultiTargetGenerator({})
-        targets = generator.list_targets()
-
-        self.console.print("\n🎯 [bold]Available Code Generation Targets:[/bold]")
-        for target in targets:
-            self.console.print(f"  • [cyan]{target}[/cyan]")
-        self.console.print("  • [cyan]all[/cyan] - Generate code for all targets")
+            self.console.print(f"❌ [red]Visualization error: {e}[/red]")

json_explorer/codegen/__init__.py

@@ -10,6 +10,7 @@
     list_supported_languages,
     register_generator,
     get_language_info,
+    list_all_language_info,
 )
 from .core import (
     CodeGenerator,
@@ -148,6 +149,7 @@ def create_config(language="go", **kwargs) -> GeneratorConfig:
     "register_generator",
     "registry",
     "get_language_info",
+    "list_all_language_info",
     # Core interfaces
     "CodeGenerator",
     "GeneratorError",

json_explorer/codegen/cli_integration.py

@@ -8,6 +8,7 @@
 import sys
 import json
 from pathlib import Path
+from rich.console import Console
 
 from . import (
     generate_from_analysis,
@@ -98,6 +99,12 @@ def add_codegen_args(parser: argparse.ArgumentParser):
         help="Case style for field names",
     )
 
+    common_group.add_argument(
+        "--verbose",
+        action="store_true",
+        help="Show generation result metadata",
+    )
+
     # Go-specific options
     go_group = parser.add_argument_group("Go-specific options")
     go_group.add_argument(
@@ -394,9 +401,9 @@ def _get_input_data(args: argparse.Namespace):
     """Get JSON input data from various sources."""
     try:
         if hasattr(args, "file") and args.file:
-            return load_json(args.file)
+            return load_json(args.file)[1]
         elif hasattr(args, "url") and args.url:
-            return load_json(args.url)
+            return load_json(args.url)[1]
         else:
             # Try to read from stdin
             return json.load(sys.stdin)
@@ -412,9 +419,9 @@ def _get_subcommand_input(args: argparse.Namespace):
     """Get input data for subcommand."""
     try:
         if args.file:
-            return load_json(args.file)
+            return load_json(args.file)[1]
         elif args.url:
-            return load_json(args.url)
+            return load_json(args.url)[1]
         elif args.stdin:
             return json.load(sys.stdin)
         else:
@@ -604,38 +611,3 @@ def validate_cli_config(args: argparse.Namespace) -> bool:
         return False
 
     return True
-
-
-def get_cli_help_text() -> str:
-    """Get formatted help text for CLI integration."""
-    return """
-Code Generation Options:
-
-  --generate LANGUAGE     Generate code in specified language
-  --output FILE          Save generated code to file
-  --config FILE          Load configuration from JSON file
-  --package-name NAME    Set package/namespace name
-  --root-name NAME       Set name for root structure
-  --list-languages       List all supported languages
-  --language-info LANG   Show detailed language information
-
-Common Generation Options:
-
-  --no-comments          Don't add comments to generated code
-  --struct-case CASE     Naming case for structs (pascal/camel/snake)
-  --field-case CASE      Naming case for fields (pascal/camel/snake)
-
-Go-Specific Options:
-
-  --no-pointers          Don't use pointers for optional fields
-  --no-json-tags         Don't generate JSON struct tags
-  --no-omitempty         Don't add omitempty to JSON tags
-  --json-tag-case CASE   Case style for JSON tags (original/snake/camel)
-
-Examples:
-
-  json_explorer --generate go --package main data.json
-  json_explorer --generate go --no-pointers --output types.go data.json
-  json_explorer --list-languages
-  json_explorer --language-info go
-    """.strip()

json_explorer/main.py

@@ -18,6 +18,7 @@
 from .cli import CLIHandler
 from .interactive import InteractiveHandler
 from .utils import load_json
+from .codegen.cli_integration import add_codegen_args, handle_codegen_command
 from rich.console import Console
 
 
@@ -37,16 +38,23 @@ def load_data(self, file_path=None, url=None):
             self.source, self.data = load_json(file_path, url)
             return True
         except Exception as e:
-            self.console.print(f"⌛ [red]Error loading data: {e}[/red]")
+            self.console.print(f"❌ [red]Error loading data: {e}[/red]")
             return False
 
     def run(self, args):
         """Main execution method."""
-        # Handle special commands that don't require data
-        if args.list_codegen_targets:
-            self.cli_handler.list_codegen_targets()
-            return 0
-
+        # Handle codegen commands (which may not require data for --list-languages)
+        if hasattr(args, "generate") or hasattr(args, "list_languages"):
+            if args.list_languages:
+                # List languages doesn't need data
+                return handle_codegen_command(args)
+            elif args.generate:
+                # Code generation needs data
+                if not self.load_data(args.file, args.url):
+                    return 1
+                return handle_codegen_command(args)
+
+        # For other operations, load data first
         if not self.load_data(args.file, args.url):
             return 1
 
@@ -60,7 +68,7 @@ def run(self, args):
 
     def _has_cli_actions(self, args) -> bool:
         """Check if any CLI-specific actions are requested."""
-        return any([args.tree, args.search, args.stats, args.plot, args.codegen])
+        return any([args.tree, args.search, args.stats, args.plot])
 
 
 def create_parser():
@@ -75,8 +83,12 @@ def create_parser():
   %(prog)s data.json --search "name" --search-type key
   %(prog)s data.json --search "isinstance(value, int) and value > 10" --search-type filter
   %(prog)s --url https://api.example.com/data --plot --tree-results
-  %(prog)s data.json --codegen java --codegen-root User --codegen-config "lombok=true,jackson=true"
-  %(prog)s data.json --codegen all --codegen-root ApiResponse
+  
+Code Generation:
+  %(prog)s data.json --generate go --output user.go --root-name User
+  %(prog)s data.json --generate go --package-name models --no-pointers
+  %(prog)s data.json --generate go --config my-config.json
+  %(prog)s --list-languages
         """,
     )
 
@@ -157,29 +169,8 @@ def create_parser():
         help="Don't open browser for HTML visualizations",
     )
 
-    # Code generation options
-    codegen_group = parser.add_argument_group("code generation options")
-    codegen_group.add_argument(
-        "--codegen",
-        type=str,
-        help="Generate code for target language (java, python, typescript, go, rust, openapi, graphql, all)",
-    )
-    codegen_group.add_argument(
-        "--codegen-root",
-        type=str,
-        default="Root",
-        help="Root class/type name for generated code (default: Root)",
-    )
-    codegen_group.add_argument(
-        "--codegen-config",
-        type=str,
-        help="Code generation configuration (key=value,key2=value2). Example: lombok=true,jackson=true,package=com.example",
-    )
-    codegen_group.add_argument(
-        "--list-codegen-targets",
-        action="store_true",
-        help="List all available code generation targets",
-    )
+    # Add codegen arguments from the dedicated module
+    add_codegen_args(parser)
 
     return parser
 
@@ -194,12 +185,20 @@ def main():
         return 1
 
     # Handle special commands that don't need file/url
-    if args.list_codegen_targets:
+    if hasattr(args, "list_languages") and args.list_languages:
         explorer = JSONExplorer()
         return explorer.run(args)
 
-    if not (args.file or args.url):
-        print("⌛ Error: You must provide a file path or --url")
+    # For codegen, we need either file or url (unless just listing languages)
+    if hasattr(args, "generate") and args.generate:
+        if not (args.file or args.url):
+            print("❌ Error: Code generation requires a file path or --url")
+            parser.print_help()
+            return 1
+
+    # For other operations, file or url is required
+    if not hasattr(args, "generate") and not (args.file or args.url):
+        print("❌ Error: You must provide a file path or --url")
         parser.print_help()
         return 1