refactor(compiler): refactor fory compiler command line (#3243)

## Why?



## What does this PR do?

refactor fory compiler command line: rename `fory compile` to `foryc`
## Related issues

#3099

## Does this PR introduce any user-facing change?



- [ ] Does this PR introduce any public API change?
- [ ] Does this PR introduce any binary protocol compatibility change?

## Benchmark

Author: chaokunyang

AGENTS.md

@@ -413,8 +413,8 @@ Fory uses binary protocols for efficient serialization and deserialization. Fory
 - **Location**: `compiler/` contains the Fory compiler, parser, IR, and code generators.
 - **Install & CLI**:
   - `cd compiler && pip install -e .`
-  - `fory compile --help`
-  - `fory compile schema.fdl --lang <langs> --output <dir>`
+  - `foryc --help`
+  - `foryc schema.fdl --lang <langs> --output <dir>`
 - **Generated code**: Never edit generated files manually; update the `.fdl`/`.proto`/`.fbs` and re-run the compiler.
 - **IDL tests**: Use `integration_tests/idl_tests/generate_idl.py` for test codegen.
   - In `integration_tests/idl_tests`, keep package names aligned with the IDL filename.

compiler/README.md

@@ -61,19 +61,19 @@ message Cat [id=103] {
 
 ```bash
 # Generate for all languages
-fory compile schema.fdl --output ./generated
+foryc schema.fdl --output ./generated
 
 # Generate for specific languages
-fory compile schema.fdl --lang java,python --output ./generated
+foryc schema.fdl --lang java,python --output ./generated
 
 # Override package name
-fory compile schema.fdl --package myapp.models --output ./generated
+foryc schema.fdl --package myapp.models --output ./generated
 
 # Language-specific output directories (protoc-style)
-fory compile schema.fdl --java_out=./src/main/java --python_out=./python/src
+foryc schema.fdl --java_out=./src/main/java --python_out=./python/src
 
 # Combine with other options
-fory compile schema.fdl --java_out=./gen --go_out=./gen/go -I ./proto
+foryc schema.fdl --java_out=./gen --go_out=./gen/go -I ./proto
 ```
 
 ### 3. Use Generated Code
@@ -394,7 +394,7 @@ struct Cat {
 ## CLI Reference
 
 ```
-fory compile [OPTIONS] FILES...
+foryc [OPTIONS] FILES...
 
 Arguments:
   FILES                 FDL files to compile
@@ -414,7 +414,7 @@ See the `examples/` directory for sample FDL files and generated output.
 
 ```bash
 # Compile the demo schema
-fory compile examples/demo.fdl --output examples/generated
+foryc examples/demo.fdl --output examples/generated
 ```
 
 ## Development
@@ -427,7 +427,7 @@ pip install -e .
 python -m fory_compiler compile examples/demo.fdl
 
 # Or use the installed command
-fory compile examples/demo.fdl
+foryc examples/demo.fdl
 ```
 
 ## License

compiler/fory_compiler/cli.py

@@ -207,49 +207,47 @@ def resolve_go_output_dir(base_go_out: Path, schema: Schema) -> Path:
 def parse_args(args: Optional[List[str]] = None) -> argparse.Namespace:
     """Parse command line arguments."""
     parser = argparse.ArgumentParser(
-        prog="fory",
+        prog="foryc",
         description="Fory IDL compiler",
     )
 
-    subparsers = parser.add_subparsers(dest="command", help="Available commands")
-
-    # compile command
-    compile_parser = subparsers.add_parser(
-        "compile",
-        help="Compile IDL files (.fdl, .proto, .fbs) to language-specific code",
+    parser.add_argument(
+        "--scan-generated",
+        action="store_true",
+        help="Scan for generated files under the current directory",
     )
 
-    compile_parser.add_argument(
+    parser.add_argument(
         "files",
-        nargs="+",
+        nargs="*",
         type=Path,
         metavar="FILE",
         help="IDL files to compile",
     )
 
-    compile_parser.add_argument(
+    parser.add_argument(
         "--lang",
         type=str,
         default="all",
         help="Comma-separated list of target languages (java,python,cpp,rust,go). Default: all",
     )
 
-    compile_parser.add_argument(
+    parser.add_argument(
         "--output",
         "-o",
         type=Path,
         default=Path("./generated"),
         help="Output directory. Default: ./generated",
     )
 
-    compile_parser.add_argument(
+    parser.add_argument(
         "--package",
         type=str,
         default=None,
         help="Override package name from FDL file",
     )
 
-    compile_parser.add_argument(
+    parser.add_argument(
         "-I",
         "--proto_path",
         "--import_path",
@@ -262,83 +260,79 @@ def parse_args(args: Optional[List[str]] = None) -> argparse.Namespace:
     )
 
     # Language-specific output directories (protoc-style)
-    compile_parser.add_argument(
+    parser.add_argument(
         "--java_out",
         type=Path,
         default=None,
         metavar="DST_DIR",
         help="Generate Java code in DST_DIR",
     )
 
-    compile_parser.add_argument(
+    parser.add_argument(
         "--python_out",
         type=Path,
         default=None,
         metavar="DST_DIR",
         help="Generate Python code in DST_DIR",
     )
 
-    compile_parser.add_argument(
+    parser.add_argument(
         "--cpp_out",
         type=Path,
         default=None,
         metavar="DST_DIR",
         help="Generate C++ code in DST_DIR",
     )
 
-    compile_parser.add_argument(
+    parser.add_argument(
         "--go_out",
         type=Path,
         default=None,
         metavar="DST_DIR",
         help="Generate Go code in DST_DIR",
     )
 
-    compile_parser.add_argument(
+    parser.add_argument(
         "--rust_out",
         type=Path,
         default=None,
         metavar="DST_DIR",
         help="Generate Rust code in DST_DIR",
     )
 
-    compile_parser.add_argument(
+    parser.add_argument(
         "--go_nested_type_style",
         type=str,
         default=None,
         choices=["camelcase", "underscore"],
         help="Go nested type naming style: camelcase or underscore (default)",
     )
 
-    compile_parser.add_argument(
+    parser.add_argument(
         "--emit-fdl",
         action="store_true",
         help="Emit translated FDL (for non-FDL inputs) for debugging",
     )
 
-    compile_parser.add_argument(
+    parser.add_argument(
         "--emit-fdl-path",
         type=Path,
         default=None,
         help="Write translated FDL to this path (file or directory)",
     )
 
-    scan_parser = subparsers.add_parser(
-        "scan-generated",
-        help="Scan for generated files under the current directory",
-    )
-    scan_parser.add_argument(
+    parser.add_argument(
         "--root",
         type=Path,
         default=Path("."),
         help="Root directory to scan (default: current directory)",
     )
-    scan_parser.add_argument(
+    parser.add_argument(
         "--relative",
         action="store_true",
         help="Print paths relative to the scan root",
     )
-    delete_group = scan_parser.add_mutually_exclusive_group()
+    delete_group = parser.add_mutually_exclusive_group()
     delete_group.add_argument(
         "--delete",
         action="store_true",
@@ -353,6 +347,23 @@ def parse_args(args: Optional[List[str]] = None) -> argparse.Namespace:
     return parser.parse_args(args)
 
 
+def normalize_args(args: Optional[List[str]]) -> List[str]:
+    """Normalize args so compile is the default command."""
+    if args is None:
+        args = sys.argv[1:]
+    if not args:
+        return []
+    if args[0] in {"-h", "--help"}:
+        return args
+    if args[0] == "--scan-generated":
+        return args
+    if args[0] == "scan-generated":
+        return ["--scan-generated", *args[1:]]
+    if args[0] == "compile":
+        return args[1:]
+    return args
+
+
 def get_languages(lang_arg: str) -> List[str]:
     """Parse the language argument into a list of languages."""
     if lang_arg == "all":
@@ -656,20 +667,17 @@ def cmd_scan_generated(args: argparse.Namespace) -> int:
 
 def main(args: Optional[List[str]] = None) -> int:
     """Main entry point."""
-    parsed = parse_args(args)
-
-    if parsed.command is None:
-        print("Usage: fory <command> [options]", file=sys.stderr)
-        print("Commands: compile, scan-generated", file=sys.stderr)
-        print("Use 'fory <command> --help' for more information", file=sys.stderr)
-        return 1
+    parsed = parse_args(normalize_args(args))
 
-    if parsed.command == "compile":
-        return cmd_compile(parsed)
-    if parsed.command == "scan-generated":
+    if parsed.scan_generated:
         return cmd_scan_generated(parsed)
 
-    return 0
+    if not parsed.files:
+        print("Usage: foryc [--scan-generated] [options] FILES...", file=sys.stderr)
+        print("Use 'foryc --help' for more information", file=sys.stderr)
+        return 1
+
+    return cmd_compile(parsed)
 
 
 if __name__ == "__main__":

compiler/pyproject.toml

@@ -42,7 +42,7 @@ classifiers = [
 keywords = ["fory", "serialization", "codegen", "idl", "compiler"]
 
 [project.scripts]
-fory = "fory_compiler.cli:main"
+foryc = "fory_compiler.cli:main"
 
 [project.urls]
 Homepage = "https://github.com/apache/fory"