integrate codegen in CLI

Author: MS-32154

.gitignore

@@ -2,3 +2,4 @@
 temp/
 venv/
 __pycache__/
+*.egg-info/

json_explorer/cli.py

@@ -5,6 +5,8 @@
 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:
@@ -26,7 +28,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}")
@@ -47,6 +49,10 @@ def run(self, args):
         if args.plot:
             self._handle_visualization(args)
 
+        # Code generation
+        if args.codegen:
+            self._handle_codegen(args)
+
         return 0
 
     def _handle_tree_display(self, tree_type):
@@ -80,7 +86,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(
@@ -91,10 +97,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
@@ -134,4 +140,72 @@ def _handle_visualization(self, args):
                 "✅ [green]Visualizations generated successfully[/green]"
             )
         except Exception as e:
-            self.console.print(f"❌ [red]Visualization error: {e}[/red]")
+            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")

json_explorer/main.py

@@ -37,11 +37,16 @@ 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
+
         if not self.load_data(args.file, args.url):
             return 1
 
@@ -55,7 +60,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])
+        return any([args.tree, args.search, args.stats, args.plot, args.codegen])
 
 
 def create_parser():
@@ -70,6 +75,8 @@ 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
         """,
     )
 
@@ -150,6 +157,30 @@ 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",
+    )
+
     return parser
 
 
@@ -162,8 +193,13 @@ def main():
         parser.print_help()
         return 1
 
+    # Handle special commands that don't need file/url
+    if args.list_codegen_targets:
+        explorer = JSONExplorer()
+        return explorer.run(args)
+
     if not (args.file or args.url):
-        print("❌ Error: You must provide a file path or --url")
+        print("⌛ Error: You must provide a file path or --url")
         parser.print_help()
         return 1