Merge branch 'master' into copilot/fix-4429

Automated changes by
[create-pull-request](https://github.com/peter-evans/create-pull-request)
GitHub action

Co-authored-by: gqcn <gqcn@users.noreply.github.com>

.github/workflows/ci-main.yml

@@ -11,6 +11,7 @@ on:
     - feature/**
     - enhance/**
     - fix/**
+    - copilot/**
 
   pull_request:
     branches:
@@ -20,6 +21,8 @@ on:
     - feature/**
     - enhance/**
     - fix/**
+    - copilot/**
+
   workflow_dispatch:
     inputs:
       debug:

.github/workflows/ci-sub.yml

@@ -12,6 +12,7 @@ on:
     - feature/**
     - enhance/**
     - fix/**
+    - copilot/**
 
   pull_request:
     branches:
@@ -21,6 +22,7 @@ on:
     - feature/**
     - enhance/**
     - fix/**
+    - copilot/**
 
 # This allows a subsequently queued workflow run to interrupt previous runs
 concurrency:

.github/workflows/golangci-lint.yml

@@ -14,6 +14,7 @@ on:
       - feature/**
       - enhance/**
       - fix/**
+      - copilot/**
       - feat/**
   pull_request:
     branches:
@@ -23,6 +24,7 @@ on:
       - feature/**
       - enhance/**
       - fix/**
+      - copilot/**
       - feat/**
 
 jobs:

.github/workflows/scripts/docker-services.sh

@@ -0,0 +1,785 @@
+#!/usr/bin/env bash
+#
+# GoFrame Docker Services Manager
+# For managing Docker services used in local development and testing
+#
+
+set -e
+
+# Container name prefix
+PREFIX="goframe"
+
+# Color definitions
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+CYAN='\033[0;36m'
+NC='\033[0m' # No Color
+
+# Service definitions
+declare -A SERVICES
+declare -A SERVICE_PORTS
+declare -A SERVICE_ENVS
+declare -A SERVICE_OPTS
+
+# Basic services
+SERVICES["etcd"]="bitnamilegacy/etcd:3.4.24"
+SERVICE_PORTS["etcd"]="2379:2379"
+SERVICE_ENVS["etcd"]="-e ALLOW_NONE_AUTHENTICATION=yes"
+
+SERVICES["redis"]="redis:7.0"
+SERVICE_PORTS["redis"]="6379:6379"
+SERVICE_OPTS["redis"]="--health-cmd 'redis-cli ping' --health-interval 10s --health-timeout 5s --health-retries 5"
+
+SERVICES["mysql"]="mysql:5.7"
+SERVICE_PORTS["mysql"]="3306:3306"
+SERVICE_ENVS["mysql"]="-e MYSQL_DATABASE=test -e MYSQL_ROOT_PASSWORD=12345678"
+
+SERVICES["mariadb"]="mariadb:11.4"
+SERVICE_PORTS["mariadb"]="3307:3306"
+SERVICE_ENVS["mariadb"]="-e MARIADB_DATABASE=test -e MARIADB_ROOT_PASSWORD=12345678"
+
+SERVICES["postgres"]="postgres:17-alpine"
+SERVICE_PORTS["postgres"]="5432:5432"
+SERVICE_ENVS["postgres"]="-e POSTGRES_PASSWORD=12345678 -e POSTGRES_USER=postgres -e POSTGRES_DB=test -e TZ=Asia/Shanghai"
+SERVICE_OPTS["postgres"]="--health-cmd pg_isready --health-interval 10s --health-timeout 5s --health-retries 5"
+
+SERVICES["mssql"]="mcr.microsoft.com/mssql/server:2022-latest"
+SERVICE_PORTS["mssql"]="1433:1433"
+SERVICE_ENVS["mssql"]="-e TZ=Asia/Shanghai -e ACCEPT_EULA=Y -e MSSQL_SA_PASSWORD=LoremIpsum86"
+
+SERVICES["clickhouse"]="clickhouse/clickhouse-server:24.11.1.2557-alpine"
+SERVICE_PORTS["clickhouse"]="9000:9000 -p 8123:8123 -p 9001:9001"
+
+SERVICES["polaris"]="polarismesh/polaris-standalone:v1.17.2"
+SERVICE_PORTS["polaris"]="8090:8090 -p 8091:8091 -p 8093:8093 -p 9090:9090 -p 9091:9091"
+
+SERVICES["oracle"]="loads/oracle-xe-11g-r2:11.2.0"
+SERVICE_PORTS["oracle"]="1521:1521"
+SERVICE_ENVS["oracle"]="-e ORACLE_ALLOW_REMOTE=true -e ORACLE_SID=XE -e ORACLE_DB_USER_NAME=system -e ORACLE_DB_PASSWORD=oracle"
+
+SERVICES["dm"]="loads/dm:v8.1.2.128_ent_x86_64_ctm_pack4"
+SERVICE_PORTS["dm"]="5236:5236"
+
+SERVICES["gaussdb"]="opengauss/opengauss:7.0.0-RC1.B023"
+SERVICE_PORTS["gaussdb"]="9950:5432"
+SERVICE_ENVS["gaussdb"]="-e GS_PASSWORD=UTpass@1234 -e TZ=Asia/Shanghai"
+SERVICE_OPTS["gaussdb"]="--privileged=true"
+
+SERVICES["zookeeper"]="zookeeper:3.8"
+SERVICE_PORTS["zookeeper"]="2181:2181"
+
+# Service groups
+GROUP_DB="mysql mariadb postgres mssql oracle dm gaussdb clickhouse"
+GROUP_CACHE="redis etcd"
+GROUP_REGISTRY="polaris zookeeper"
+GROUP_ALL="etcd redis mysql mariadb postgres mssql clickhouse polaris oracle dm gaussdb zookeeper"
+
+# Working directories
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(dirname "$SCRIPT_DIR")"
+WORKFLOW_DIR="$PROJECT_ROOT/.github/workflows"
+
+# Print colored messages
+print_info() {
+    echo -e "${BLUE}[INFO]${NC} $1"
+}
+
+print_success() {
+    echo -e "${GREEN}[OK]${NC} $1"
+}
+
+print_warning() {
+    echo -e "${YELLOW}[WARN]${NC} $1"
+}
+
+print_error() {
+    echo -e "${RED}[ERROR]${NC} $1"
+}
+
+# Check if Docker is available
+check_docker() {
+    if ! command -v docker &> /dev/null; then
+        print_error "Docker is not installed or not in PATH"
+        exit 1
+    fi
+    if ! docker info &> /dev/null; then
+        print_error "Docker service is not running"
+        exit 1
+    fi
+}
+
+# Get container name
+get_container_name() {
+    echo "${PREFIX}-$1"
+}
+
+# Start a single service
+start_service() {
+    local service=$1
+    local container_name=$(get_container_name "$service")
+    local image="${SERVICES[$service]}"
+    local ports="${SERVICE_PORTS[$service]}"
+    local envs="${SERVICE_ENVS[$service]}"
+    local opts="${SERVICE_OPTS[$service]}"
+
+    if [ -z "$image" ]; then
+        print_error "Unknown service: $service"
+        return 1
+    fi
+
+    # Check if container already exists
+    if docker ps -a --format '{{.Names}}' | grep -q "^${container_name}$"; then
+        if docker ps --format '{{.Names}}' | grep -q "^${container_name}$"; then
+            print_warning "$service is already running"
+            return 0
+        else
+            print_info "Starting existing container $service..."
+            docker start "$container_name" > /dev/null
+            print_success "$service started"
+            return 0
+        fi
+    fi
+
+    print_info "Starting $service..."
+    
+    # Build docker run command
+    local cmd="docker run -d --name $container_name"
+    
+    # Add port mappings
+    for port in $ports; do
+        cmd="$cmd -p $port"
+    done
+    
+    # Add environment variables
+    if [ -n "$envs" ]; then
+        cmd="$cmd $envs"
+    fi
+    
+    # Add other options
+    if [ -n "$opts" ]; then
+        cmd="$cmd $opts"
+    fi
+    
+    cmd="$cmd $image"
+    
+    if eval "$cmd" > /dev/null 2>&1; then
+        print_success "$service started (container: $container_name)"
+    else
+        print_error "Failed to start $service"
+        return 1
+    fi
+}
+
+# Stop a single service
+stop_service() {
+    local service=$1
+    local container_name=$(get_container_name "$service")
+
+    if docker ps --format '{{.Names}}' | grep -q "^${container_name}$"; then
+        print_info "Stopping $service..."
+        docker stop "$container_name" > /dev/null
+        print_success "$service stopped"
+    else
+        print_warning "$service is not running"
+    fi
+}
+
+# Remove a single service
+remove_service() {
+    local service=$1
+    local container_name=$(get_container_name "$service")
+
+    if docker ps -a --format '{{.Names}}' | grep -q "^${container_name}$"; then
+        print_info "Removing $service..."
+        docker rm -f "$container_name" > /dev/null
+        print_success "$service removed"
+    else
+        print_warning "$service container does not exist"
+    fi
+}
+
+# View service logs
+logs_service() {
+    local service=$1
+    local container_name=$(get_container_name "$service")
+    local lines=${2:-100}
+
+    if docker ps -a --format '{{.Names}}' | grep -q "^${container_name}$"; then
+        docker logs --tail "$lines" -f "$container_name"
+    else
+        print_error "$service container does not exist"
+        return 1
+    fi
+}
+
+# Start docker-compose service
+start_compose_service() {
+    local service=$1
+    local compose_file=""
+    
+    case $service in
+        apollo)
+            compose_file="$WORKFLOW_DIR/apollo/docker-compose.yml"
+            ;;
+        nacos)
+            compose_file="$WORKFLOW_DIR/nacos/docker-compose.yml"
+            ;;
+        redis-cluster)
+            compose_file="$WORKFLOW_DIR/redis/docker-compose.yml"
+            ;;
+        consul)
+            compose_file="$WORKFLOW_DIR/consul/docker-compose.yml"
+            ;;
+        *)
+            print_error "Unknown compose service: $service"
+            return 1
+            ;;
+    esac
+    
+    if [ -f "$compose_file" ]; then
+        print_info "Starting $service (docker-compose)..."
+        docker compose -f "$compose_file" up -d
+        print_success "$service started"
+    else
+        print_error "Compose file does not exist: $compose_file"
+        return 1
+    fi
+}
+
+# Stop docker-compose service
+stop_compose_service() {
+    local service=$1
+    local compose_file=""
+    
+    case $service in
+        apollo)
+            compose_file="$WORKFLOW_DIR/apollo/docker-compose.yml"
+            ;;
+        nacos)
+            compose_file="$WORKFLOW_DIR/nacos/docker-compose.yml"
+            ;;
+        redis-cluster)
+            compose_file="$WORKFLOW_DIR/redis/docker-compose.yml"
+            ;;
+        consul)
+            compose_file="$WORKFLOW_DIR/consul/docker-compose.yml"
+            ;;
+        *)
+            print_error "Unknown compose service: $service"
+            return 1
+            ;;
+    esac
+    
+    if [ -f "$compose_file" ]; then
+        print_info "Stopping $service (docker-compose)..."
+        docker compose -f "$compose_file" down
+        print_success "$service stopped"
+    else
+        print_error "Compose file does not exist: $compose_file"
+        return 1
+    fi
+}
+
+# Show service status
+show_status() {
+    echo ""
+    echo -e "${CYAN}========== GoFrame Docker Services Status ==========${NC}"
+    echo ""
+    printf "%-15s %-12s %-30s %s\n" "SERVICE" "STATUS" "CONTAINER" "PORTS"
+    echo "--------------------------------------------------------------------------------"
+    
+    for service in $GROUP_ALL; do
+        local container_name=$(get_container_name "$service")
+        local status="stopped"
+        local ports="-"
+        
+        if docker ps --format '{{.Names}}' 2>/dev/null | grep -q "^${container_name}$"; then
+            status="${GREEN}running${NC}"
+            ports=$(docker port "$container_name" 2>/dev/null | tr '\n' ' ' || echo "-")
+        elif docker ps -a --format '{{.Names}}' 2>/dev/null | grep -q "^${container_name}$"; then
+            status="${YELLOW}stopped${NC}"
+        else
+            status="${RED}not created${NC}"
+        fi
+        
+        printf "%-15s %-22b %-30s %s\n" "$service" "$status" "$container_name" "$ports"
+    done
+    
+    echo ""
+    echo -e "${CYAN}========== Compose Services ==========${NC}"
+    echo ""
+    
+    for compose_svc in apollo nacos redis-cluster consul; do
+        local running=0
+        case $compose_svc in
+            apollo)
+                running=$(docker ps --filter "name=apollo" --format '{{.Names}}' 2>/dev/null | wc -l)
+                ;;
+            nacos)
+                running=$(docker ps --filter "name=nacos" --format '{{.Names}}' 2>/dev/null | wc -l)
+                ;;
+            redis-cluster)
+                running=$(docker ps --filter "name=redis-" --format '{{.Names}}' 2>/dev/null | wc -l)
+                ;;
+            consul)
+                running=$(docker ps --filter "name=consul" --format '{{.Names}}' 2>/dev/null | wc -l)
+                ;;
+        esac
+        
+        if [ "$running" -gt 0 ]; then
+            printf "%-15s ${GREEN}running${NC} (%d containers)\n" "$compose_svc" "$running"
+        else
+            printf "%-15s ${RED}stopped${NC}\n" "$compose_svc"
+        fi
+    done
+    
+    echo ""
+}
+
+# Show service information
+show_service_info() {
+    echo ""
+    echo -e "${CYAN}========== Available Services ==========${NC}"
+    echo ""
+    echo -e "${YELLOW}Basic Services (standalone containers):${NC}"
+    echo ""
+    printf "%-15s %-50s %s\n" "SERVICE" "IMAGE" "PORTS"
+    echo "--------------------------------------------------------------------------------"
+    
+    for service in $GROUP_ALL; do
+        printf "%-15s %-50s %s\n" "$service" "${SERVICES[$service]}" "${SERVICE_PORTS[$service]}"
+    done
+    
+    echo ""
+    echo -e "${YELLOW}Compose Services (multi-container):${NC}"
+    echo "  apollo        - Apollo Config Center (8080, 8070, 8060, 13306)"
+    echo "  nacos         - Nacos Registry (8848, 9848, 9555)"
+    echo "  redis-cluster - Redis Primary-Replica + Sentinel Cluster (6380-6382, 26379-26381)"
+    echo "  consul        - Consul Service Discovery (8500, 8600)"
+    echo ""
+    echo -e "${YELLOW}Service Groups:${NC}"
+    echo "  db       - Databases: $GROUP_DB"
+    echo "  cache    - Cache: $GROUP_CACHE"
+    echo "  registry - Registry: $GROUP_REGISTRY"
+    echo "  all      - All basic services"
+    echo ""
+}
+
+# Show help
+show_help() {
+    echo ""
+    echo -e "${CYAN}GoFrame Docker Services Manager${NC}"
+    echo ""
+    echo "Usage: $0 <command> [service|group] [options]"
+    echo ""
+    echo "Commands:"
+    echo "  start <service|group>    Start service or service group"
+    echo "  stop <service|group>     Stop service or service group"
+    echo "  restart <service|group>  Restart service or service group"
+    echo "  remove <service|group>   Remove service container"
+    echo "  logs <service> [lines]   View service logs (default 100 lines)"
+    echo "  status                   Show all service status"
+    echo "  info                     Show available service information"
+    echo "  clean                    Remove all goframe containers"
+    echo "  pull [service]           Pull images"
+    echo ""
+    echo "Services:"
+    echo "  Basic: etcd, redis, mysql, mariadb, postgres, mssql,"
+    echo "         clickhouse, polaris, oracle, dm, gaussdb, zookeeper"
+    echo "  Compose: apollo, nacos, redis-cluster, consul"
+    echo ""
+    echo "Service Groups:"
+    echo "  db       - All database services"
+    echo "  cache    - Cache services (redis, etcd)"
+    echo "  registry - Registry services (polaris, zookeeper)"
+    echo "  all      - All basic services"
+    echo ""
+    echo "Examples:"
+    echo "  $0 start mysql           # Start MySQL"
+    echo "  $0 start db              # Start all databases"
+    echo "  $0 start all             # Start all basic services"
+    echo "  $0 start apollo          # Start Apollo (compose)"
+    echo "  $0 stop all              # Stop all basic services"
+    echo "  $0 logs mysql 50         # View last 50 lines of MySQL logs"
+    echo "  $0 status                # View service status"
+    echo ""
+}
+
+# Parse service groups
+parse_services() {
+    local input=$1
+    case $input in
+        db)
+            echo "$GROUP_DB"
+            ;;
+        cache)
+            echo "$GROUP_CACHE"
+            ;;
+        registry)
+            echo "$GROUP_REGISTRY"
+            ;;
+        all)
+            echo "$GROUP_ALL"
+            ;;
+        *)
+            echo "$input"
+            ;;
+    esac
+}
+
+# Check if it's a compose service
+is_compose_service() {
+    local service=$1
+    case $service in
+        apollo|nacos|redis-cluster|consul)
+            return 0
+            ;;
+        *)
+            return 1
+            ;;
+    esac
+}
+
+# Pull images
+pull_images() {
+    local services=$1
+    
+    if [ -z "$services" ]; then
+        services="$GROUP_ALL"
+    fi
+    
+    for service in $services; do
+        if [ -n "${SERVICES[$service]}" ]; then
+            print_info "Pulling image: ${SERVICES[$service]}"
+            docker pull "${SERVICES[$service]}"
+        fi
+    done
+}
+
+# Clean all goframe containers
+clean_all() {
+    print_info "Removing all $PREFIX containers..."
+    local containers=$(docker ps -a --filter "name=$PREFIX" --format '{{.Names}}')
+    
+    if [ -n "$containers" ]; then
+        for container in $containers; do
+            docker rm -f "$container" > /dev/null
+            print_success "Removed: $container"
+        done
+    else
+        print_info "No $PREFIX containers found"
+    fi
+}
+
+# Get service status mark
+get_service_status_mark() {
+    local service=$1
+    local container_name=$(get_container_name "$service")
+    
+    if docker ps --format '{{.Names}}' 2>/dev/null | grep -q "^${container_name}$"; then
+        echo -e "${GREEN}*${NC}"
+    else
+        echo " "
+    fi
+}
+
+# Get compose service status mark
+get_compose_status_mark() {
+    local service=$1
+    local running=0
+    
+    case $service in
+        apollo)
+            running=$(docker ps --filter "name=apollo" --format '{{.Names}}' 2>/dev/null | wc -l)
+            ;;
+        nacos)
+            running=$(docker ps --filter "name=nacos" --format '{{.Names}}' 2>/dev/null | wc -l)
+            ;;
+        redis-cluster)
+            running=$(docker ps --filter "name=redis-" --format '{{.Names}}' 2>/dev/null | wc -l)
+            ;;
+        consul)
+            running=$(docker ps --filter "name=consul" --format '{{.Names}}' 2>/dev/null | wc -l)
+            ;;
+    esac
+    
+    if [ "$running" -gt 0 ]; then
+        echo -e "${GREEN}*${NC}"
+    else
+        echo " "
+    fi
+}
+
+# Service selection menu
+select_service_menu() {
+    local action=$1
+    local action_name=$2
+    
+    echo ""
+    echo -e "${CYAN}========== Select Service to ${action_name} ==========${NC}"
+    
+    # Show running status for stop/restart/logs operations
+    if [[ "$action" == "stop" || "$action" == "restart" || "$action" == "logs" ]]; then
+        echo -e "  (${GREEN}*${NC} indicates running)"
+    fi
+    echo ""
+    echo -e "${YELLOW}Basic Services:${NC}"
+    printf "  %b1) etcd         %b2) redis        %b3) mysql\n" \
+        "$(get_service_status_mark etcd)" "$(get_service_status_mark redis)" "$(get_service_status_mark mysql)"
+    printf "  %b4) mariadb      %b5) postgres     %b6) mssql\n" \
+        "$(get_service_status_mark mariadb)" "$(get_service_status_mark postgres)" "$(get_service_status_mark mssql)"
+    printf "  %b7) clickhouse   %b8) polaris      %b9) oracle\n" \
+        "$(get_service_status_mark clickhouse)" "$(get_service_status_mark polaris)" "$(get_service_status_mark oracle)"
+    printf " %b10) dm          %b11) gaussdb     %b12) zookeeper\n" \
+        "$(get_service_status_mark dm)" "$(get_service_status_mark gaussdb)" "$(get_service_status_mark zookeeper)"
+    echo ""
+    echo -e "${YELLOW}Compose Services:${NC}"
+    printf " %b13) apollo      %b14) nacos       %b15) redis-cluster\n" \
+        "$(get_compose_status_mark apollo)" "$(get_compose_status_mark nacos)" "$(get_compose_status_mark redis-cluster)"
+    printf " %b16) consul\n" "$(get_compose_status_mark consul)"
+    echo ""
+    echo -e "${YELLOW}Service Groups:${NC}"
+    echo "  17) db (all databases)    18) cache (cache services)"
+    echo "  19) registry (registry services) 20) all (all basic services)"
+    echo ""
+    echo "   0) Back to main menu"
+    echo ""
+    read -p "Select [0-20]: " svc_choice
+    
+    local svc=""
+    case $svc_choice in
+        1) svc="etcd" ;;
+        2) svc="redis" ;;
+        3) svc="mysql" ;;
+        4) svc="mariadb" ;;
+        5) svc="postgres" ;;
+        6) svc="mssql" ;;
+        7) svc="clickhouse" ;;
+        8) svc="polaris" ;;
+        9) svc="oracle" ;;
+        10) svc="dm" ;;
+        11) svc="gaussdb" ;;
+        12) svc="zookeeper" ;;
+        13) svc="apollo" ;;
+        14) svc="nacos" ;;
+        15) svc="redis-cluster" ;;
+        16) svc="consul" ;;
+        17) svc="db" ;;
+        18) svc="cache" ;;
+        19) svc="registry" ;;
+        20) svc="all" ;;
+        0) return ;;
+        *)
+            print_error "Invalid selection"
+            return
+            ;;
+    esac
+    
+    case $action in
+        start)
+            if is_compose_service "$svc"; then
+                start_compose_service "$svc"
+            else
+                for s in $(parse_services "$svc"); do
+                    start_service "$s"
+                done
+            fi
+            ;;
+        stop)
+            if is_compose_service "$svc"; then
+                stop_compose_service "$svc"
+            else
+                for s in $(parse_services "$svc"); do
+                    stop_service "$s"
+                done
+            fi
+            ;;
+        restart)
+            if is_compose_service "$svc"; then
+                stop_compose_service "$svc"
+                start_compose_service "$svc"
+            else
+                for s in $(parse_services "$svc"); do
+                    stop_service "$s"
+                    start_service "$s"
+                done
+            fi
+            ;;
+        remove)
+            for s in $(parse_services "$svc"); do
+                remove_service "$s"
+            done
+            ;;
+        logs)
+            if is_compose_service "$svc"; then
+                print_error "For Compose services, please use 'docker compose logs'"
+            else
+                read -p "Number of lines (default 100): " lines
+                lines=${lines:-100}
+                logs_service "$svc" "$lines"
+            fi
+            ;;
+        pull)
+            pull_images "$(parse_services "$svc")"
+            ;;
+    esac
+}
+
+# Interactive menu
+interactive_menu() {
+    while true; do
+        echo ""
+        echo -e "${CYAN}========== GoFrame Docker Services Manager ==========${NC}"
+        echo ""
+        echo "  1) Start Service"
+        echo "  2) Stop Service"
+        echo "  3) Restart Service"
+        echo "  4) Remove Service"
+        echo "  5) View Logs"
+        echo "  6) View Status"
+        echo "  7) Service Info"
+        echo "  8) Clean All Containers"
+        echo "  9) Pull Images"
+        echo "  0) Exit"
+        echo ""
+        read -p "Select operation [0-9]: " choice
+        
+        case $choice in
+            1)
+                select_service_menu "start" "Start"
+                ;;
+            2)
+                select_service_menu "stop" "Stop"
+                ;;
+            3)
+                select_service_menu "restart" "Restart"
+                ;;
+            4)
+                select_service_menu "remove" "Remove"
+                ;;
+            5)
+                select_service_menu "logs" "View Logs"
+                ;;
+            6)
+                show_status
+                ;;
+            7)
+                show_service_info
+                ;;
+            8)
+                read -p "Confirm removing all goframe containers? [y/N]: " confirm
+                if [[ "$confirm" =~ ^[Yy]$ ]]; then
+                    clean_all
+                fi
+                ;;
+            9)
+                select_service_menu "pull" "Pull Images"
+                ;;
+            0)
+                echo "Goodbye!"
+                exit 0
+                ;;
+            *)
+                print_error "Invalid selection"
+                ;;
+        esac
+    done
+}
+
+# Main function
+main() {
+    check_docker
+    
+    if [ $# -eq 0 ]; then
+        interactive_menu
+        exit 0
+    fi
+    
+    local command=$1
+    local target=$2
+    local extra=$3
+    
+    case $command in
+        start)
+            if [ -z "$target" ]; then
+                print_error "Please specify service name or service group"
+                exit 1
+            fi
+            if is_compose_service "$target"; then
+                start_compose_service "$target"
+            else
+                for service in $(parse_services "$target"); do
+                    start_service "$service"
+                done
+            fi
+            ;;
+        stop)
+            if [ -z "$target" ]; then
+                print_error "Please specify service name or service group"
+                exit 1
+            fi
+            if is_compose_service "$target"; then
+                stop_compose_service "$target"
+            else
+                for service in $(parse_services "$target"); do
+                    stop_service "$service"
+                done
+            fi
+            ;;
+        restart)
+            if [ -z "$target" ]; then
+                print_error "Please specify service name or service group"
+                exit 1
+            fi
+            if is_compose_service "$target"; then
+                stop_compose_service "$target"
+                start_compose_service "$target"
+            else
+                for service in $(parse_services "$target"); do
+                    stop_service "$service"
+                    start_service "$service"
+                done
+            fi
+            ;;
+        remove|rm)
+            if [ -z "$target" ]; then
+                print_error "Please specify service name or service group"
+                exit 1
+            fi
+            for service in $(parse_services "$target"); do
+                remove_service "$service"
+            done
+            ;;
+        logs)
+            if [ -z "$target" ]; then
+                print_error "Please specify service name"
+                exit 1
+            fi
+            logs_service "$target" "${extra:-100}"
+            ;;
+        status|ps)
+            show_status
+            ;;
+        info|list)
+            show_service_info
+            ;;
+        clean)
+            clean_all
+            ;;
+        pull)
+            pull_images "$target"
+            ;;
+        help|--help|-h)
+            show_help
+            ;;
+        *)
+            print_error "Unknown command: $command"
+            show_help
+            exit 1
+            ;;
+    esac
+}
+
+main "$@"

.gitignore

@@ -24,4 +24,5 @@ node_modules
 .docusaurus
 output
 .example/
-.golangci.bck.yml
+.golangci.bck.yml
+*.exe

.golangci.yml

@@ -1,7 +1,6 @@
 version: "2"
 run:
   concurrency: 4
-  go: "1.25"
   modules-download-mode: readonly
   issues-exit-code: 2
   tests: false

.make_version.sh

@@ -1,19 +1,16 @@
 #!/usr/bin/env bash
 
-# Function to detect OS and set sed parameters
-setup_sed() {
+# Function to run sed in-place with OS-specific options
+sed_inplace() {
     if [[ "$OSTYPE" == "darwin"* ]]; then
-        # macOS
-        SED_INPLACE="sed -i ''"
+        # macOS - requires empty string after -i
+        sed -i '' "$@"
     else
         # Linux/Windows Git Bash
-        SED_INPLACE="sed -i"
+        sed -i "$@"
     fi
 }
 
-# Initialize sed command
-setup_sed
-
 if [ $# -ne 2 ]; then
     echo "Parameter exception, please execute in the format of $0 [directory] [version number]"
     echo "PS：$0 ./ v2.4.0"
@@ -43,10 +40,11 @@ fi
 
 if [[ true ]]; then
     # Use sed to replace the version number in version.go
-    $SED_INPLACE 's/VERSION = ".*"/VERSION = "'${newVersion}'"/' version.go
+    sed_inplace 's/VERSION = ".*"/VERSION = "'${newVersion}'"/' version.go
 
     # Use sed to replace the version number in README.MD
-    $SED_INPLACE 's/version=[^"]*/version='${newVersion}'/' README.MD
+    sed_inplace 's/version=[^"]*/version='${newVersion}'/' README.MD
+    sed_inplace 's/version=[^"]*/version='${newVersion}'/' README.zh_CN.MD
 fi
 
 if [ -f "go.work" ]; then
@@ -70,6 +68,8 @@ for file in `find ${workdir} -name go.mod`; do
     fi
 
     cd $goModPath
+
+    # Add replace directive for local development.
     if [ $goModPath = "./cmd/gf" ]; then
         mv go.work go.work.version.bak
         go mod edit -replace github.com/gogf/gf/v2=../../
@@ -81,20 +81,20 @@ for file in `find ${workdir} -name go.mod`; do
         go mod edit -replace github.com/gogf/gf/contrib/drivers/sqlite/v2=../../contrib/drivers/sqlite
     fi
     # Remove indirect dependencies
-    sed -i '/\/\/ indirect/d' go.mod
+    sed_inplace '/\/\/ indirect/d' go.mod
     go mod tidy
     # Remove toolchain line if exists
-    $SED_INPLACE '/^toolchain/d' go.mod
+    sed_inplace '/^toolchain/d' go.mod
 
-    # Upgrading only GoFrame related libraries, sometimes even if a version number is specified, 
+    # Upgrading only GoFrame related libraries, sometimes even if a version number is specified,
     # it may not be possible to successfully upgrade. Please confirm before submitting the code
     go list -f "{{if and (not .Indirect) (not .Main)}}{{.Path}}@${newVersion}{{end}}" -m all | grep "^github.com/gogf/gf"
-    go list -f "{{if and (not .Indirect) (not .Main)}}{{.Path}}@${newVersion}{{end}}" -m all | grep "^github.com/gogf/gf" | xargs -L1 go get -v 
+    go list -f "{{if and (not .Indirect) (not .Main)}}{{.Path}}@${newVersion}{{end}}" -m all | grep "^github.com/gogf/gf" | xargs -L1 go get -v
     # Remove indirect dependencies
-    sed -i '/\/\/ indirect/d' go.mod
+    sed_inplace '/\/\/ indirect/d' go.mod
     go mod tidy
     # Remove toolchain line if exists
-    $SED_INPLACE '/^toolchain/d' go.mod
+    sed_inplace '/^toolchain/d' go.mod
     if [ $goModPath = "./cmd/gf" ]; then
         go mod edit -dropreplace github.com/gogf/gf/v2
         go mod edit -dropreplace github.com/gogf/gf/contrib/drivers/clickhouse/v2

Makefile

@@ -76,3 +76,13 @@ subsync: subup
 		git push origin; \
 	fi; \
 	cd ..;
+
+# manage docker services for local development
+# usage: make docker or make docker cmd=start svc=mysql
+.PHONY: docker
+docker:
+	@if [ -z "$(cmd)" ]; then \
+		./.github/workflows/scripts/docker-services.sh; \
+	else \
+		./.github/workflows/scripts/docker-services.sh $(cmd) $(svc) $(extra); \
+	fi

README.MD

@@ -19,6 +19,7 @@ English | [简体中文](README.zh_CN.MD)
 [![GitHub closed issues](https://img.shields.io/github/issues-closed/gogf/gf?style=flat)](https://github.com/gogf/gf/issues?q=is%3Aissue+is%3Aclosed)
 ![Stars](https://img.shields.io/github/stars/gogf/gf?style=flat)
 ![Forks](https://img.shields.io/github/forks/gogf/gf?style=flat)
+[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/gogf/gf)
 
 </div>
 
@@ -35,7 +36,7 @@ go get -u github.com/gogf/gf/v2
 - Official Site: [https://goframe.org](https://goframe.org)
 - Official Site(en): [https://goframe.org/en](https://goframe.org/en)
 - 国内镜像: [https://goframe.org.cn](https://goframe.org.cn)
-- Mirror Site: [Github Pages](https://pages.goframe.org)
+- Mirror Site: [https://pages.goframe.org](https://pages.goframe.org)
 - Mirror Site: [Offline Docs](https://github.com/gogf/goframe.org-pdf?tab=readme-ov-file#%E6%9C%80%E6%96%B0%E7%89%88%E6%9C%AC)
 - GoDoc API: [https://pkg.go.dev/github.com/gogf/gf/v2](https://pkg.go.dev/github.com/gogf/gf/v2)
 - Doc Source: [https://github.com/gogf/gf-site](https://github.com/gogf/gf-site)
@@ -45,7 +46,7 @@ go get -u github.com/gogf/gf/v2
 💖 [Thanks to all the contributors who made GoFrame possible](https://github.com/gogf/gf/graphs/contributors) 💖
 
 <a href="https://github.com/gogf/gf/graphs/contributors">
-<img src="https://goframe.org/img/contributors.svg?version=v2.9.7" alt="goframe contributors"/>
+<img src="https://goframe.org/img/contributors.svg?version=v2.10.0" alt="goframe contributors"/>
 </a>
 
 ## License

README.zh_CN.MD

@@ -19,6 +19,7 @@
 [![GitHub closed issues](https://img.shields.io/github/issues-closed/gogf/gf?style=flat)](https://github.com/gogf/gf/issues?q=is%3Aissue+is%3Aclosed)
 ![Stars](https://img.shields.io/github/stars/gogf/gf?style=flat)
 ![Forks](https://img.shields.io/github/forks/gogf/gf?style=flat)
+[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/gogf/gf)
 
 </div>
 
@@ -35,7 +36,7 @@ go get -u github.com/gogf/gf/v2
 - 官方网站: [https://goframe.org](https://goframe.org)
 - 官方网站(en): [https://goframe.org/en](https://goframe.org/en)
 - 国内镜像: [https://goframe.org.cn](https://goframe.org.cn)
-- 镜像网站: [Github Pages](https://pages.goframe.org)
+- 镜像网站: [https://pages.goframe.org](https://pages.goframe.org)
 - 镜像网站: [离线文档](https://github.com/gogf/goframe.org-pdf?tab=readme-ov-file#%E6%9C%80%E6%96%B0%E7%89%88%E6%9C%AC)
 - Go包文档: [https://pkg.go.dev/github.com/gogf/gf/v2](https://pkg.go.dev/github.com/gogf/gf/v2)
 - 文档源码: [https://github.com/gogf/gf-site](https://github.com/gogf/gf-site)
@@ -45,7 +46,7 @@ go get -u github.com/gogf/gf/v2
 💖 [感谢所有使 GoFrame 成为可能的贡献者](https://github.com/gogf/gf/graphs/contributors) 💖
 
 <a href="https://github.com/gogf/gf/graphs/contributors">
-<img src="https://goframe.org/img/contributors.svg?version=v2.9.5" alt="goframe contributors"/>
+<img src="https://goframe.org/img/contributors.svg?version=v2.10.0" alt="goframe contributors"/>
 </a>
 
 ## 许可证

cmd/gf/go.mod

@@ -3,13 +3,13 @@ module github.com/gogf/gf/cmd/gf/v2
 go 1.23.0
 
 require (
-	github.com/gogf/gf/contrib/drivers/clickhouse/v2 v2.9.7
-	github.com/gogf/gf/contrib/drivers/mssql/v2 v2.9.7
-	github.com/gogf/gf/contrib/drivers/mysql/v2 v2.9.7
-	github.com/gogf/gf/contrib/drivers/oracle/v2 v2.9.7
-	github.com/gogf/gf/contrib/drivers/pgsql/v2 v2.9.7
-	github.com/gogf/gf/contrib/drivers/sqlite/v2 v2.9.7
-	github.com/gogf/gf/v2 v2.9.7
+	github.com/gogf/gf/contrib/drivers/clickhouse/v2 v2.10.0
+	github.com/gogf/gf/contrib/drivers/mssql/v2 v2.10.0
+	github.com/gogf/gf/contrib/drivers/mysql/v2 v2.10.0
+	github.com/gogf/gf/contrib/drivers/oracle/v2 v2.10.0
+	github.com/gogf/gf/contrib/drivers/pgsql/v2 v2.10.0
+	github.com/gogf/gf/contrib/drivers/sqlite/v2 v2.10.0
+	github.com/gogf/gf/v2 v2.10.0
 	github.com/gogf/selfupdate v0.0.0-20231215043001-5c48c528462f
 	github.com/olekukonko/tablewriter v1.1.0
 	github.com/schollz/progressbar/v3 v3.15.0

cmd/gf/go.sum

@@ -46,6 +46,20 @@ github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiU
 github.com/go-sql-driver/mysql v1.4.0/go.mod h1:zAC/RDZ24gD3HViQzih4MyKcchzm+sOG5ZlKdlhCg5w=
 github.com/go-sql-driver/mysql v1.7.1 h1:lUIinVbN1DY0xBg0eMOzmmtGoHwWBbvnWubQUrtU8EI=
 github.com/go-sql-driver/mysql v1.7.1/go.mod h1:OXbVy3sEdcQ2Doequ6Z5BW6fXNQTmx+9S1MCJN5yJMI=
+github.com/gogf/gf/contrib/drivers/clickhouse/v2 v2.10.0 h1:9PTchr92xIJej4tq5c+HOHSU7LGOHr3YfD7tuf23LW4=
+github.com/gogf/gf/contrib/drivers/clickhouse/v2 v2.10.0/go.mod h1:eKtLMs9uccxFvmoKOUCRQ/Se3nxhzEZwF0Ir13qbk5g=
+github.com/gogf/gf/contrib/drivers/mssql/v2 v2.10.0 h1:mBs6XpNM34IdZPZv4Kv3LA8yhP2UisbONMLfnQVFvKM=
+github.com/gogf/gf/contrib/drivers/mssql/v2 v2.10.0/go.mod h1:mChbF9FrmiYMSE2rG3zdxI/oSTwaHsR5KbINAgt3KcY=
+github.com/gogf/gf/contrib/drivers/mysql/v2 v2.10.0 h1:UvqxwinkelKxwdwnKUfdy51/ls4RL7MCeJqAZOVAy0I=
+github.com/gogf/gf/contrib/drivers/mysql/v2 v2.10.0/go.mod h1:6v7oGBF9wv59WERJIOJxXmLhkUcxwON3tPYW3AZ7wbY=
+github.com/gogf/gf/contrib/drivers/oracle/v2 v2.10.0 h1:MvhoMaz8YYj4WJuYzKGDdzJYiieiYiqp0vjoOshfOF4=
+github.com/gogf/gf/contrib/drivers/oracle/v2 v2.10.0/go.mod h1:vb2fx33RGhjhOaocOTEFvlEuBSGHss5S0lZ4sS3XK6E=
+github.com/gogf/gf/contrib/drivers/pgsql/v2 v2.10.0 h1:39+jbTenm7KBj4hO2C8ANAxVHpX/7OuRDs1VcGC9ylA=
+github.com/gogf/gf/contrib/drivers/pgsql/v2 v2.10.0/go.mod h1:B0s0fVzn0W220E8UTpSGzrrGKsop5KcB90twBeLCiz0=
+github.com/gogf/gf/contrib/drivers/sqlite/v2 v2.10.0 h1:OyAH7Ls2c9Un7CJiAq7G6eY1jWIICRkN8C5SyM94rnY=
+github.com/gogf/gf/contrib/drivers/sqlite/v2 v2.10.0/go.mod h1:fwhAMG0qZpeHbbP2JE78rJRfV7eBbu9jXkxTMM1lwyo=
+github.com/gogf/gf/v2 v2.10.0 h1:rzDROlyqGMe/eM6dCalSR8dZOuMIdLhmxKSH1DGhbFs=
+github.com/gogf/gf/v2 v2.10.0/go.mod h1:Svl1N+E8G/QshU2DUbh/3J/AJauqCgUnxHurXWR4Qx0=
 github.com/gogf/selfupdate v0.0.0-20231215043001-5c48c528462f h1:7xfXR/BhG3JDqO1s45n65Oyx9t4E/UqDOXep6jXdLCM=
 github.com/gogf/selfupdate v0.0.0-20231215043001-5c48c528462f/go.mod h1:HnYoio6S7VaFJdryKcD/r9HgX+4QzYfr00XiXUo/xz0=
 github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=

cmd/gf/internal/cmd/cmd_env.go

@@ -37,11 +37,13 @@ type cEnvInput struct {
 type cEnvOutput struct{}
 
 func (c cEnv) Index(ctx context.Context, in cEnvInput) (out *cEnvOutput, err error) {
-	result, err := gproc.ShellExec(ctx, "go env")
-	if err != nil {
-		mlog.Fatal(err)
-	}
+	result, execErr := gproc.ShellExec(ctx, "go env")
+	// Note: go env may return non-zero exit code when there are warnings (e.g., invalid characters in env vars),
+	// but it still outputs valid environment variables. So we only fail if result is empty.
 	if result == "" {
+		if execErr != nil {
+			mlog.Fatal(execErr)
+		}
 		mlog.Fatal(`retrieving Golang environment variables failed, did you install Golang?`)
 	}
 	var (
@@ -59,7 +61,9 @@ func (c cEnv) Index(ctx context.Context, in cEnvInput) (out *cEnvOutput, err err
 		}
 		match, _ := gregex.MatchString(`(.+?)=(.*)`, line)
 		if len(match) < 3 {
-			mlog.Fatalf(`invalid Golang environment variable: "%s"`, line)
+			// Skip lines that don't match key=value format (e.g., warning messages from go env)
+			mlog.Debugf(`invalid Golang environment variable: "%s"`, line)
+			continue
 		}
 		array = append(array, []string{gstr.Trim(match[1]), gstr.Trim(match[2])})
 	}

cmd/gf/internal/cmd/cmd_init.go

@@ -50,8 +50,9 @@ gf init my-mono-repo -a
 gf init my-project -u
 gf init my-project -g "github.com/myorg/myproject"
 gf init -r github.com/gogf/template-single my-project
-gf init -r github.com/gogf/template-single my-project -s
 gf init -r github.com/gogf/examples/httpserver/jwt my-jwt
+gf init -r github.com/gogf/gf/cmd/gf/v2@v2.9.7 mygf
+gf init -r github.com/gogf/gf/cmd/gf/v2 mygf -s
 gf init -i
 `
 	cInitNameBrief = `
@@ -237,6 +238,9 @@ func (c cInit) initFromBuiltin(ctx context.Context, in cInitInput) (out *cInitOu
 		return
 	}
 
+	// Format the generated Go files.
+	utils.GoFmt(in.Name)
+
 	// Update the GoFrame version.
 	if in.Update {
 		mlog.Print("update goframe...")

cmd/gf/internal/cmd/cmd_z_init_test.go

@@ -15,9 +15,11 @@ import (
 )
 
 var (
-	ctx    = context.Background()
-	testDB gdb.DB
-	link   = "mysql:root:12345678@tcp(127.0.0.1:3306)/test?loc=Local&parseTime=true"
+	ctx      = context.Background()
+	testDB   gdb.DB
+	testPgDB gdb.DB
+	link     = "mysql:root:12345678@tcp(127.0.0.1:3306)/test?loc=Local&parseTime=true"
+	linkPg   = "pgsql:postgres:12345678@tcp(127.0.0.1:5432)/test"
 )
 
 func init() {
@@ -28,6 +30,10 @@ func init() {
 	if err != nil {
 		panic(err)
 	}
+	// PostgreSQL connection (optional, may not be available in all environments)
+	testPgDB, _ = gdb.New(gdb.ConfigNode{
+		Link: linkPg,
+	})
 }
 
 func dropTableWithDb(db gdb.DB, table string) {
@@ -36,3 +42,11 @@ func dropTableWithDb(db gdb.DB, table string) {
 		gtest.Error(err)
 	}
 }
+
+// dropTableStd uses standard SQL syntax compatible with MySQL and PostgreSQL.
+func dropTableStd(db gdb.DB, table string) {
+	dropTableStmt := fmt.Sprintf("DROP TABLE IF EXISTS %s", table)
+	if _, err := db.Exec(ctx, dropTableStmt); err != nil {
+		gtest.Error(err)
+	}
+}

cmd/gf/internal/cmd/cmd_z_unit_env_test.go

@@ -0,0 +1,84 @@
+// Copyright GoFrame gf Author(https://goframe.org). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package cmd
+
+import (
+	"testing"
+
+	"github.com/gogf/gf/v2/test/gtest"
+	"github.com/gogf/gf/v2/text/gregex"
+	"github.com/gogf/gf/v2/text/gstr"
+)
+
+func Test_Env_Index(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test that env command runs without error
+		_, err := Env.Index(ctx, cEnvInput{})
+		t.AssertNil(err)
+	})
+}
+
+func Test_Env_ParseGoEnvOutput(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test parsing normal go env output
+		lines := []string{
+			"set GOPATH=C:\\Users\\test\\go",
+			"set GOROOT=C:\\Go",
+			"set GOOS=windows",
+			"GOARCH=amd64", // Unix format without "set " prefix
+			"CGO_ENABLED=0",
+		}
+
+		for _, line := range lines {
+			line = gstr.Trim(line)
+			if gstr.Pos(line, "set ") == 0 {
+				line = line[4:]
+			}
+			match, _ := gregex.MatchString(`(.+?)=(.*)`, line)
+			t.Assert(len(match) >= 3, true)
+		}
+	})
+}
+
+func Test_Env_ParseGoEnvOutput_WithWarnings(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test parsing go env output that contains warning messages
+		// These lines should be skipped without causing errors
+		lines := []string{
+			"go: stripping unprintable or unescapable characters from %\"GOPROXY\"%",
+			"go: warning: some warning message",
+			"# this is a comment",
+			"",
+			"set GOPATH=C:\\Users\\test\\go",
+			"set GOOS=windows",
+		}
+
+		array := make([][]string, 0)
+		for _, line := range lines {
+			line = gstr.Trim(line)
+			if line == "" {
+				continue
+			}
+			if gstr.Pos(line, "set ") == 0 {
+				line = line[4:]
+			}
+			match, _ := gregex.MatchString(`(.+?)=(.*)`, line)
+			if len(match) < 3 {
+				// Skip lines that don't match key=value format (e.g., warning messages)
+				continue
+			}
+			array = append(array, []string{gstr.Trim(match[1]), gstr.Trim(match[2])})
+		}
+
+		// Should have parsed 2 valid environment variables
+		t.Assert(len(array), 2)
+		t.Assert(array[0][0], "GOPATH")
+		t.Assert(array[0][1], "C:\\Users\\test\\go")
+		t.Assert(array[1][0], "GOOS")
+		t.Assert(array[1][1], "windows")
+	})
+}

cmd/gf/internal/cmd/cmd_z_unit_fix_test.go

@@ -10,6 +10,7 @@ import (
 	"testing"
 
 	"github.com/gogf/gf/v2/test/gtest"
+	"github.com/gogf/gf/v2/text/gstr"
 )
 
 func Test_Fix_doFixV25Content(t *testing.T) {
@@ -22,3 +23,82 @@ func Test_Fix_doFixV25Content(t *testing.T) {
 		t.AssertNil(err)
 	})
 }
+
+func Test_Fix_doFixV25Content_WithReplacement(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			f       = cFix{}
+			content = `s.BindHookHandlerByMap("/path", map[string]ghttp.HandlerFunc{
+				ghttp.HookBeforeServe: func(r *ghttp.Request) {},
+			})`
+		)
+		newContent, err := f.doFixV25Content(content)
+		t.AssertNil(err)
+		// Verify the replacement was made
+		t.Assert(gstr.Contains(newContent, "map[ghttp.HookName]ghttp.HandlerFunc"), true)
+		t.Assert(gstr.Contains(newContent, "map[string]ghttp.HandlerFunc"), false)
+	})
+}
+
+func Test_Fix_doFixV25Content_NoMatch(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			f       = cFix{}
+			content = `package main
+
+func main() {
+	fmt.Println("Hello World")
+}
+`
+		)
+		newContent, err := f.doFixV25Content(content)
+		t.AssertNil(err)
+		// Content should remain unchanged
+		t.Assert(newContent, content)
+	})
+}
+
+func Test_Fix_doFixV25Content_MultipleMatches(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			f       = cFix{}
+			content = `
+s.BindHookHandlerByMap("/path1", map[string]ghttp.HandlerFunc{})
+s.BindHookHandlerByMap("/path2", map[string]ghttp.HandlerFunc{})
+`
+		)
+		newContent, err := f.doFixV25Content(content)
+		t.AssertNil(err)
+		// Both should be replaced
+		count := gstr.Count(newContent, "map[ghttp.HookName]ghttp.HandlerFunc")
+		t.Assert(count, 2)
+	})
+}
+
+func Test_Fix_doFixV25Content_EmptyContent(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			f       = cFix{}
+			content = ""
+		)
+		newContent, err := f.doFixV25Content(content)
+		t.AssertNil(err)
+		t.Assert(newContent, "")
+	})
+}
+
+func Test_Fix_doFixV25Content_ComplexPath(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			f       = cFix{}
+			content = `s.BindHookHandlerByMap("/api/v1/user/{id}/profile", map[string]ghttp.HandlerFunc{
+				ghttp.HookBeforeServe: func(r *ghttp.Request) {
+					r.Response.Write("before")
+				},
+			})`
+		)
+		newContent, err := f.doFixV25Content(content)
+		t.AssertNil(err)
+		t.Assert(gstr.Contains(newContent, "map[ghttp.HookName]ghttp.HandlerFunc"), true)
+	})
+}

cmd/gf/internal/cmd/cmd_z_unit_gen_ctrl_test.go

@@ -22,7 +22,7 @@ func Test_Gen_Ctrl_Default(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		var (
 			path      = gfile.Temp(guid.S())
-			apiFolder = gtest.DataPath("genctrl", "api")
+			apiFolder = gtest.DataPath("genctrl", "default", "api")
 			in        = genctrl.CGenCtrlInput{
 				SrcFolder:     apiFolder,
 				DstFolder:     path,
@@ -39,7 +39,7 @@ func Test_Gen_Ctrl_Default(t *testing.T) {
 
 		err = gfile.Mkdir(path)
 		t.AssertNil(err)
-		defer gfile.Remove(path)
+		defer gfile.RemoveAll(path)
 
 		_, err = genctrl.CGenCtrl{}.Ctrl(ctx, in)
 		t.AssertNil(err)
@@ -49,7 +49,7 @@ func Test_Gen_Ctrl_Default(t *testing.T) {
 			genApi       = apiFolder + filepath.FromSlash("/article/article.go")
 			genApiExpect = apiFolder + filepath.FromSlash("/article/article_expect.go")
 		)
-		defer gfile.Remove(genApi)
+		defer gfile.RemoveAll(genApi)
 		t.Assert(gfile.GetContents(genApi), gfile.GetContents(genApiExpect))
 
 		// files
@@ -67,7 +67,7 @@ func Test_Gen_Ctrl_Default(t *testing.T) {
 		})
 
 		// content
-		testPath := gtest.DataPath("genctrl", "controller")
+		testPath := gtest.DataPath("genctrl", "default", "controller")
 		expectFiles := []string{
 			testPath + filepath.FromSlash("/article/article.go"),
 			testPath + filepath.FromSlash("/article/article_new.go"),
@@ -84,6 +84,104 @@ func Test_Gen_Ctrl_Default(t *testing.T) {
 	})
 }
 
+func Test_Gen_Ctrl_Default_Multi(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			path      = gfile.Temp(guid.S())
+			apiFolder = gtest.DataPath("genctrl", "multi", "api")
+			in        = genctrl.CGenCtrlInput{
+				SrcFolder:     apiFolder,
+				DstFolder:     path,
+				WatchFile:     "",
+				SdkPath:       "",
+				SdkStdVersion: false,
+				SdkNoV1:       false,
+				Clear:         false,
+				Merge:         false,
+			}
+		)
+
+		err := gutil.FillStructWithDefault(&in)
+		t.AssertNil(err)
+
+		err = gfile.Mkdir(path)
+		t.AssertNil(err)
+		defer gfile.RemoveAll(path)
+
+		_, err = genctrl.CGenCtrl{}.Ctrl(ctx, in)
+		t.AssertNil(err)
+
+		// apiInterface file
+		var (
+			genApiSlice = []string{
+				apiFolder + filepath.FromSlash("/admin/article/article.go"),
+				apiFolder + filepath.FromSlash("/admin/user/user.go"),
+				apiFolder + filepath.FromSlash("/app/user/user.go"),
+				apiFolder + filepath.FromSlash("/app/user/user_ext/user_ext.go"),
+			}
+			genApiSliceExpect = []string{
+				apiFolder + filepath.FromSlash("/admin/article/article_expect.go"),
+				apiFolder + filepath.FromSlash("/admin/user/user_expect.go"),
+				apiFolder + filepath.FromSlash("/app/user/user_expect.go"),
+				apiFolder + filepath.FromSlash("/app/user/user_ext/user_ext_expect.go"),
+			}
+		)
+
+		for i := range genApiSlice {
+			t.Assert(gfile.GetContents(genApiSlice[i]), gfile.GetContents(genApiSliceExpect[i]))
+			gfile.RemoveAll(genApiSlice[i])
+		}
+
+		// files
+		files, err := gfile.ScanDir(path, "*.go", true)
+		t.AssertNil(err)
+		t.Assert(files, []string{
+			path + filepath.FromSlash("/admin/article/article.go"),
+			path + filepath.FromSlash("/admin/article/article_new.go"),
+			path + filepath.FromSlash("/admin/article/article_v1_create.go"),
+
+			path + filepath.FromSlash("/admin/user/user.go"),
+			path + filepath.FromSlash("/admin/user/user_new.go"),
+			path + filepath.FromSlash("/admin/user/user_v1_create.go"),
+
+			path + filepath.FromSlash("/app/user/user.go"),
+			path + filepath.FromSlash("/app/user/user_ext/user_ext.go"),
+			path + filepath.FromSlash("/app/user/user_ext/user_ext_new.go"),
+			path + filepath.FromSlash("/app/user/user_ext/user_ext_v1_create.go"),
+			path + filepath.FromSlash("/app/user/user_ext/user_ext_v1_update.go"),
+
+			path + filepath.FromSlash("/app/user/user_new.go"),
+			path + filepath.FromSlash("/app/user/user_v1_create.go"),
+			path + filepath.FromSlash("/app/user/user_v1_update.go"),
+		})
+
+		// content
+		testPath := gtest.DataPath("genctrl", "multi", "controller")
+		expectFiles := []string{
+			testPath + filepath.FromSlash("/admin/article/article.go"),
+			testPath + filepath.FromSlash("/admin/article/article_new.go"),
+			testPath + filepath.FromSlash("/admin/article/article_v1_create.go"),
+
+			testPath + filepath.FromSlash("/admin/user/user.go"),
+			testPath + filepath.FromSlash("/admin/user/user_new.go"),
+			testPath + filepath.FromSlash("/admin/user/user_v1_create.go"),
+
+			testPath + filepath.FromSlash("/app/user/user.go"),
+			testPath + filepath.FromSlash("/app/user/user_ext/user_ext.go"),
+			testPath + filepath.FromSlash("/app/user/user_ext/user_ext_new.go"),
+			testPath + filepath.FromSlash("/app/user/user_ext/user_ext_v1_create.go"),
+			testPath + filepath.FromSlash("/app/user/user_ext/user_ext_v1_update.go"),
+
+			testPath + filepath.FromSlash("/app/user/user_new.go"),
+			testPath + filepath.FromSlash("/app/user/user_v1_create.go"),
+			testPath + filepath.FromSlash("/app/user/user_v1_update.go"),
+		}
+		for i := range files {
+			t.Assert(gfile.GetContents(files[i]), gfile.GetContents(expectFiles[i]))
+		}
+	})
+}
+
 func expectFilesContent(t *gtest.T, paths []string, expectPaths []string) {
 	for i, expectFile := range expectPaths {
 		val := gfile.GetContents(paths[i])
@@ -98,8 +196,8 @@ func Test_Gen_Ctrl_UseMerge_AddNewFile(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		var (
 			ctrlPath = gfile.Temp(guid.S())
-			//ctrlPath  = gtest.DataPath("issue", "3460", "controller")
-			apiFolder = gtest.DataPath("genctrl-merge", "add_new_file", "api")
+			// ctrlPath  = gtest.DataPath("issue", "3460", "controller")
+			apiFolder = gtest.DataPath("genctrl", "merge", "add_new_file", "api")
 			in        = genctrl.CGenCtrlInput{
 				SrcFolder: apiFolder,
 				DstFolder: ctrlPath,
@@ -118,7 +216,7 @@ type DictTypeAddRes struct {
 
 		err := gfile.Mkdir(ctrlPath)
 		t.AssertNil(err)
-		defer gfile.Remove(ctrlPath)
+		defer gfile.RemoveAll(ctrlPath)
 
 		_, err = genctrl.CGenCtrl{}.Ctrl(ctx, in)
 		t.AssertNil(err)
@@ -127,7 +225,7 @@ type DictTypeAddRes struct {
 			genApi       = filepath.Join(apiFolder, "/dict/dict.go")
 			genApiExpect = filepath.Join(apiFolder, "/dict/dict_expect.go")
 		)
-		defer gfile.Remove(genApi)
+		defer gfile.RemoveAll(genApi)
 		t.Assert(gfile.GetContents(genApi), gfile.GetContents(genApiExpect))
 
 		genCtrlFiles, err := gfile.ScanDir(ctrlPath, "*.go", true)
@@ -138,7 +236,7 @@ type DictTypeAddRes struct {
 			filepath.Join(ctrlPath, "/dict/dict_v1_dict_type.go"),
 		})
 
-		expectCtrlPath := gtest.DataPath("genctrl-merge", "add_new_file", "controller")
+		expectCtrlPath := gtest.DataPath("genctrl", "merge", "add_new_file", "controller")
 		expectFiles := []string{
 			filepath.Join(expectCtrlPath, "/dict/dict.go"),
 			filepath.Join(expectCtrlPath, "/dict/dict_new.go"),
@@ -152,7 +250,7 @@ type DictTypeAddRes struct {
 		newApiFilePath := filepath.Join(apiFolder, "/dict/v1/test_new.go")
 		err = gfile.PutContents(newApiFilePath, testNewApiFile)
 		t.AssertNil(err)
-		defer gfile.Remove(newApiFilePath)
+		defer gfile.RemoveAll(newApiFilePath)
 
 		// Then execute the command
 		_, err = genctrl.CGenCtrl{}.Ctrl(ctx, in)
@@ -179,8 +277,8 @@ func Test_Gen_Ctrl_UseMerge_AddNewCtrl(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		var (
 			ctrlPath = gfile.Temp(guid.S())
-			//ctrlPath  = gtest.DataPath("issue", "3460", "controller")
-			apiFolder = gtest.DataPath("genctrl-merge", "add_new_ctrl", "api")
+			// ctrlPath  = gtest.DataPath("issue", "3460", "controller")
+			apiFolder = gtest.DataPath("genctrl", "merge", "add_new_ctrl", "api")
 			in        = genctrl.CGenCtrlInput{
 				SrcFolder: apiFolder,
 				DstFolder: ctrlPath,
@@ -190,7 +288,7 @@ func Test_Gen_Ctrl_UseMerge_AddNewCtrl(t *testing.T) {
 
 		err := gfile.Mkdir(ctrlPath)
 		t.AssertNil(err)
-		defer gfile.Remove(ctrlPath)
+		defer gfile.RemoveAll(ctrlPath)
 
 		_, err = genctrl.CGenCtrl{}.Ctrl(ctx, in)
 		t.AssertNil(err)
@@ -199,7 +297,7 @@ func Test_Gen_Ctrl_UseMerge_AddNewCtrl(t *testing.T) {
 			genApi       = filepath.Join(apiFolder, "/dict/dict.go")
 			genApiExpect = filepath.Join(apiFolder, "/dict/dict_expect.go")
 		)
-		defer gfile.Remove(genApi)
+		defer gfile.RemoveAll(genApi)
 		t.Assert(gfile.GetContents(genApi), gfile.GetContents(genApiExpect))
 
 		genCtrlFiles, err := gfile.ScanDir(ctrlPath, "*.go", true)
@@ -210,7 +308,7 @@ func Test_Gen_Ctrl_UseMerge_AddNewCtrl(t *testing.T) {
 			filepath.Join(ctrlPath, "/dict/dict_v1_dict_type.go"),
 		})
 
-		expectCtrlPath := gtest.DataPath("genctrl-merge", "add_new_ctrl", "controller")
+		expectCtrlPath := gtest.DataPath("genctrl", "merge", "add_new_ctrl", "controller")
 		expectFiles := []string{
 			filepath.Join(expectCtrlPath, "/dict/dict.go"),
 			filepath.Join(expectCtrlPath, "/dict/dict_new.go"),
@@ -236,7 +334,7 @@ type DictTypeAddRes struct {
 		err = gfile.PutContentsAppend(dictModuleFileName, testNewApiFile)
 		t.AssertNil(err)
 
-		//==================================
+		// ==================================
 		// Then execute the command
 		_, err = genctrl.CGenCtrl{}.Ctrl(ctx, in)
 		t.AssertNil(err)
@@ -262,7 +360,7 @@ func Test_Gen_Ctrl_UseMerge_Issue3460(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		var (
 			ctrlPath = gfile.Temp(guid.S())
-			//ctrlPath  = gtest.DataPath("issue", "3460", "controller")
+			// ctrlPath  = gtest.DataPath("issue", "3460", "controller")
 			apiFolder = gtest.DataPath("issue", "3460", "api")
 			in        = genctrl.CGenCtrlInput{
 				SrcFolder:     apiFolder,
@@ -278,7 +376,7 @@ func Test_Gen_Ctrl_UseMerge_Issue3460(t *testing.T) {
 
 		err := gfile.Mkdir(ctrlPath)
 		t.AssertNil(err)
-		defer gfile.Remove(ctrlPath)
+		defer gfile.RemoveAll(ctrlPath)
 
 		_, err = genctrl.CGenCtrl{}.Ctrl(ctx, in)
 		t.AssertNil(err)

cmd/gf/internal/cmd/cmd_z_unit_gen_dao_issue_test.go

@@ -460,3 +460,398 @@ func Test_Gen_Dao_Issue3749(t *testing.T) {
 		}
 	})
 }
+
+// https://github.com/gogf/gf/issues/4629
+// Test tables pattern matching with * wildcard.
+func Test_Gen_Dao_Issue4629_TablesPattern_Star(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			err         error
+			db          = testDB
+			table1      = "trade_order"
+			table2      = "trade_item"
+			table3      = "user_info"
+			table4      = "user_log"
+			table5      = "config"
+			sqlFilePath = gtest.DataPath(`gendao`, `tables_pattern.sql`)
+		)
+		dropTableStd(db, table1)
+		dropTableStd(db, table2)
+		dropTableStd(db, table3)
+		dropTableStd(db, table4)
+		dropTableStd(db, table5)
+		t.AssertNil(execSqlFile(db, sqlFilePath))
+		defer dropTableStd(db, table1)
+		defer dropTableStd(db, table2)
+		defer dropTableStd(db, table3)
+		defer dropTableStd(db, table4)
+		defer dropTableStd(db, table5)
+
+		var (
+			path  = gfile.Temp(guid.S())
+			group = "test"
+			in    = gendao.CGenDaoInput{
+				Path:   path,
+				Link:   link,
+				Group:  group,
+				Tables: "trade_*", // Should match trade_order, trade_item
+			}
+		)
+		err = gutil.FillStructWithDefault(&in)
+		t.AssertNil(err)
+
+		err = gfile.Mkdir(path)
+		t.AssertNil(err)
+
+		pwd := gfile.Pwd()
+		err = gfile.Chdir(path)
+		t.AssertNil(err)
+		defer gfile.Chdir(pwd)
+		defer gfile.RemoveAll(path)
+
+		_, err = gendao.CGenDao{}.Dao(ctx, in)
+		t.AssertNil(err)
+
+		// Should generate 2 dao files: trade_order.go, trade_item.go
+		generatedFiles, err := gfile.ScanDir(gfile.Join(path, "dao"), "*.go", false)
+		t.AssertNil(err)
+		t.Assert(len(generatedFiles), 2)
+
+		// Verify the correct files are generated
+		t.Assert(gfile.Exists(gfile.Join(path, "dao", "trade_order.go")), true)
+		t.Assert(gfile.Exists(gfile.Join(path, "dao", "trade_item.go")), true)
+		// user_* and config should NOT be generated
+		t.Assert(gfile.Exists(gfile.Join(path, "dao", "user_info.go")), false)
+		t.Assert(gfile.Exists(gfile.Join(path, "dao", "user_log.go")), false)
+		t.Assert(gfile.Exists(gfile.Join(path, "dao", "config.go")), false)
+	})
+}
+
+// https://github.com/gogf/gf/issues/4629
+// Test tables pattern matching with multiple patterns.
+func Test_Gen_Dao_Issue4629_TablesPattern_Multiple(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			err         error
+			db          = testDB
+			table1      = "trade_order"
+			table2      = "trade_item"
+			table3      = "user_info"
+			table4      = "user_log"
+			table5      = "config"
+			sqlFilePath = gtest.DataPath(`gendao`, `tables_pattern.sql`)
+		)
+		dropTableStd(db, table1)
+		dropTableStd(db, table2)
+		dropTableStd(db, table3)
+		dropTableStd(db, table4)
+		dropTableStd(db, table5)
+		t.AssertNil(execSqlFile(db, sqlFilePath))
+		defer dropTableStd(db, table1)
+		defer dropTableStd(db, table2)
+		defer dropTableStd(db, table3)
+		defer dropTableStd(db, table4)
+		defer dropTableStd(db, table5)
+
+		var (
+			path  = gfile.Temp(guid.S())
+			group = "test"
+			in    = gendao.CGenDaoInput{
+				Path:   path,
+				Link:   link,
+				Group:  group,
+				Tables: "trade_*,user_*", // Should match trade_order, trade_item, user_info, user_log
+			}
+		)
+		err = gutil.FillStructWithDefault(&in)
+		t.AssertNil(err)
+
+		err = gfile.Mkdir(path)
+		t.AssertNil(err)
+
+		pwd := gfile.Pwd()
+		err = gfile.Chdir(path)
+		t.AssertNil(err)
+		defer gfile.Chdir(pwd)
+		defer gfile.RemoveAll(path)
+
+		_, err = gendao.CGenDao{}.Dao(ctx, in)
+		t.AssertNil(err)
+
+		// Should generate 4 dao files
+		generatedFiles, err := gfile.ScanDir(gfile.Join(path, "dao"), "*.go", false)
+		t.AssertNil(err)
+		t.Assert(len(generatedFiles), 4)
+
+		// Verify the correct files are generated
+		t.Assert(gfile.Exists(gfile.Join(path, "dao", "trade_order.go")), true)
+		t.Assert(gfile.Exists(gfile.Join(path, "dao", "trade_item.go")), true)
+		t.Assert(gfile.Exists(gfile.Join(path, "dao", "user_info.go")), true)
+		t.Assert(gfile.Exists(gfile.Join(path, "dao", "user_log.go")), true)
+		// config should NOT be generated
+		t.Assert(gfile.Exists(gfile.Join(path, "dao", "config.go")), false)
+	})
+}
+
+// https://github.com/gogf/gf/issues/4629
+// Test tables pattern mixed with exact table name.
+func Test_Gen_Dao_Issue4629_TablesPattern_Mixed(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			err         error
+			db          = testDB
+			table1      = "trade_order"
+			table2      = "trade_item"
+			table3      = "user_info"
+			table4      = "user_log"
+			table5      = "config"
+			sqlFilePath = gtest.DataPath(`gendao`, `tables_pattern.sql`)
+		)
+		dropTableStd(db, table1)
+		dropTableStd(db, table2)
+		dropTableStd(db, table3)
+		dropTableStd(db, table4)
+		dropTableStd(db, table5)
+		t.AssertNil(execSqlFile(db, sqlFilePath))
+		defer dropTableStd(db, table1)
+		defer dropTableStd(db, table2)
+		defer dropTableStd(db, table3)
+		defer dropTableStd(db, table4)
+		defer dropTableStd(db, table5)
+
+		var (
+			path  = gfile.Temp(guid.S())
+			group = "test"
+			in    = gendao.CGenDaoInput{
+				Path:   path,
+				Link:   link,
+				Group:  group,
+				Tables: "trade_*,config", // Pattern + exact name
+			}
+		)
+		err = gutil.FillStructWithDefault(&in)
+		t.AssertNil(err)
+
+		err = gfile.Mkdir(path)
+		t.AssertNil(err)
+
+		pwd := gfile.Pwd()
+		err = gfile.Chdir(path)
+		t.AssertNil(err)
+		defer gfile.Chdir(pwd)
+		defer gfile.RemoveAll(path)
+
+		_, err = gendao.CGenDao{}.Dao(ctx, in)
+		t.AssertNil(err)
+
+		// Should generate 3 dao files: trade_order.go, trade_item.go, config.go
+		generatedFiles, err := gfile.ScanDir(gfile.Join(path, "dao"), "*.go", false)
+		t.AssertNil(err)
+		t.Assert(len(generatedFiles), 3)
+
+		// Verify the correct files are generated
+		t.Assert(gfile.Exists(gfile.Join(path, "dao", "trade_order.go")), true)
+		t.Assert(gfile.Exists(gfile.Join(path, "dao", "trade_item.go")), true)
+		t.Assert(gfile.Exists(gfile.Join(path, "dao", "config.go")), true)
+		// user_* should NOT be generated
+		t.Assert(gfile.Exists(gfile.Join(path, "dao", "user_info.go")), false)
+		t.Assert(gfile.Exists(gfile.Join(path, "dao", "user_log.go")), false)
+	})
+}
+
+// https://github.com/gogf/gf/issues/4629
+// Test tables pattern with ? wildcard (single character match).
+func Test_Gen_Dao_Issue4629_TablesPattern_Question(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			err         error
+			db          = testDB
+			table1      = "trade_order"
+			table2      = "trade_item"
+			table3      = "user_info"
+			table4      = "user_log"
+			table5      = "config"
+			sqlFilePath = gtest.DataPath(`gendao`, `tables_pattern.sql`)
+		)
+		dropTableStd(db, table1)
+		dropTableStd(db, table2)
+		dropTableStd(db, table3)
+		dropTableStd(db, table4)
+		dropTableStd(db, table5)
+		t.AssertNil(execSqlFile(db, sqlFilePath))
+		defer dropTableStd(db, table1)
+		defer dropTableStd(db, table2)
+		defer dropTableStd(db, table3)
+		defer dropTableStd(db, table4)
+		defer dropTableStd(db, table5)
+
+		var (
+			path  = gfile.Temp(guid.S())
+			group = "test"
+			in    = gendao.CGenDaoInput{
+				Path:   path,
+				Link:   link,
+				Group:  group,
+				Tables: "user_???", // ? matches single char: user_log (3 chars) but not user_info (4 chars)
+			}
+		)
+		err = gutil.FillStructWithDefault(&in)
+		t.AssertNil(err)
+
+		err = gfile.Mkdir(path)
+		t.AssertNil(err)
+
+		pwd := gfile.Pwd()
+		err = gfile.Chdir(path)
+		t.AssertNil(err)
+		defer gfile.Chdir(pwd)
+		defer gfile.RemoveAll(path)
+
+		_, err = gendao.CGenDao{}.Dao(ctx, in)
+		t.AssertNil(err)
+
+		// Should generate 1 dao file: user_log.go (3 chars after user_)
+		generatedFiles, err := gfile.ScanDir(gfile.Join(path, "dao"), "*.go", false)
+		t.AssertNil(err)
+		t.Assert(len(generatedFiles), 1)
+
+		// Verify only user_log is generated
+		t.Assert(gfile.Exists(gfile.Join(path, "dao", "user_log.go")), true)
+		t.Assert(gfile.Exists(gfile.Join(path, "dao", "user_info.go")), false) // 4 chars, doesn't match
+	})
+}
+
+// https://github.com/gogf/gf/issues/4629
+// Test that exact table names still work (backward compatibility).
+func Test_Gen_Dao_Issue4629_TablesPattern_ExactNames(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			err         error
+			db          = testDB
+			table1      = "trade_order"
+			table2      = "trade_item"
+			table3      = "user_info"
+			table4      = "user_log"
+			table5      = "config"
+			sqlFilePath = gtest.DataPath(`gendao`, `tables_pattern.sql`)
+		)
+		dropTableStd(db, table1)
+		dropTableStd(db, table2)
+		dropTableStd(db, table3)
+		dropTableStd(db, table4)
+		dropTableStd(db, table5)
+		t.AssertNil(execSqlFile(db, sqlFilePath))
+		defer dropTableStd(db, table1)
+		defer dropTableStd(db, table2)
+		defer dropTableStd(db, table3)
+		defer dropTableStd(db, table4)
+		defer dropTableStd(db, table5)
+
+		var (
+			path  = gfile.Temp(guid.S())
+			group = "test"
+			in    = gendao.CGenDaoInput{
+				Path:   path,
+				Link:   link,
+				Group:  group,
+				Tables: "trade_order,config", // Exact names, no patterns
+			}
+		)
+		err = gutil.FillStructWithDefault(&in)
+		t.AssertNil(err)
+
+		err = gfile.Mkdir(path)
+		t.AssertNil(err)
+
+		pwd := gfile.Pwd()
+		err = gfile.Chdir(path)
+		t.AssertNil(err)
+		defer gfile.Chdir(pwd)
+		defer gfile.RemoveAll(path)
+
+		_, err = gendao.CGenDao{}.Dao(ctx, in)
+		t.AssertNil(err)
+
+		// Should generate 2 dao files
+		generatedFiles, err := gfile.ScanDir(gfile.Join(path, "dao"), "*.go", false)
+		t.AssertNil(err)
+		t.Assert(len(generatedFiles), 2)
+
+		// Verify exactly the specified tables are generated
+		t.Assert(gfile.Exists(gfile.Join(path, "dao", "trade_order.go")), true)
+		t.Assert(gfile.Exists(gfile.Join(path, "dao", "config.go")), true)
+		t.Assert(gfile.Exists(gfile.Join(path, "dao", "trade_item.go")), false)
+	})
+}
+
+// https://github.com/gogf/gf/issues/4629
+// Test tables pattern matching with PostgreSQL.
+func Test_Gen_Dao_Issue4629_TablesPattern_PgSql(t *testing.T) {
+	if testPgDB == nil {
+		t.Skip("PostgreSQL database not available, skipping test")
+		return
+	}
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			err         error
+			db          = testPgDB
+			table1      = "trade_order"
+			table2      = "trade_item"
+			table3      = "user_info"
+			table4      = "user_log"
+			table5      = "config"
+			sqlFilePath = gtest.DataPath(`gendao`, `tables_pattern.sql`)
+		)
+		dropTableStd(db, table1)
+		dropTableStd(db, table2)
+		dropTableStd(db, table3)
+		dropTableStd(db, table4)
+		dropTableStd(db, table5)
+		t.AssertNil(execSqlFile(db, sqlFilePath))
+		defer dropTableStd(db, table1)
+		defer dropTableStd(db, table2)
+		defer dropTableStd(db, table3)
+		defer dropTableStd(db, table4)
+		defer dropTableStd(db, table5)
+
+		// Test tables pattern with tablesEx pattern
+		var (
+			path  = gfile.Temp(guid.S())
+			group = "test"
+			in    = gendao.CGenDaoInput{
+				Path:     path,
+				Link:     linkPg,
+				Group:    group,
+				Tables:   "trade_*,user_*,config", // Match only our test tables
+				TablesEx: "user_*",                // Exclude user_* tables
+			}
+		)
+		err = gutil.FillStructWithDefault(&in)
+		t.AssertNil(err)
+
+		err = gfile.Mkdir(path)
+		t.AssertNil(err)
+
+		pwd := gfile.Pwd()
+		err = gfile.Chdir(path)
+		t.AssertNil(err)
+		defer gfile.Chdir(pwd)
+		defer gfile.RemoveAll(path)
+
+		_, err = gendao.CGenDao{}.Dao(ctx, in)
+		t.AssertNil(err)
+
+		// Should generate 3 dao files: trade_order, trade_item, config (user_* excluded by tablesEx)
+		generatedFiles, err := gfile.ScanDir(gfile.Join(path, "dao"), "*.go", false)
+		t.AssertNil(err)
+		t.Assert(len(generatedFiles), 3)
+
+		// Verify the correct files are generated
+		t.Assert(gfile.Exists(gfile.Join(path, "dao", "trade_order.go")), true)
+		t.Assert(gfile.Exists(gfile.Join(path, "dao", "trade_item.go")), true)
+		t.Assert(gfile.Exists(gfile.Join(path, "dao", "config.go")), true)
+		// user_* should NOT be generated (excluded by tablesEx)
+		t.Assert(gfile.Exists(gfile.Join(path, "dao", "user_info.go")), false)
+		t.Assert(gfile.Exists(gfile.Join(path, "dao", "user_log.go")), false)
+	})
+}

cmd/gf/internal/cmd/cmd_z_unit_gen_dao_sharding_test.go

@@ -18,6 +18,92 @@ import (
 	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/gendao"
 )
 
+// Test_Gen_Dao_Sharding_Overlapping tests the fix for issue #4603.
+// When sharding patterns have overlapping prefixes (like "a_?", "a_b_?", "a_c_?"),
+// longer (more specific) patterns should be matched first.
+// https://github.com/gogf/gf/issues/4603
+func Test_Gen_Dao_Sharding_Overlapping(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			err         error
+			db          = testDB
+			tableA1     = "a_1"
+			tableA2     = "a_2"
+			tableAB1    = "a_b_1"
+			tableAB2    = "a_b_2"
+			tableAC1    = "a_c_1"
+			tableAC2    = "a_c_2"
+			sqlFilePath = gtest.DataPath(`gendao`, `sharding`, `sharding_overlapping.sql`)
+		)
+		dropTableWithDb(db, tableA1)
+		dropTableWithDb(db, tableA2)
+		dropTableWithDb(db, tableAB1)
+		dropTableWithDb(db, tableAB2)
+		dropTableWithDb(db, tableAC1)
+		dropTableWithDb(db, tableAC2)
+		t.AssertNil(execSqlFile(db, sqlFilePath))
+		defer dropTableWithDb(db, tableA1)
+		defer dropTableWithDb(db, tableA2)
+		defer dropTableWithDb(db, tableAB1)
+		defer dropTableWithDb(db, tableAB2)
+		defer dropTableWithDb(db, tableAC1)
+		defer dropTableWithDb(db, tableAC2)
+
+		var (
+			path  = gfile.Temp(guid.S())
+			group = "test"
+			in    = gendao.CGenDaoInput{
+				Path:   path,
+				Link:   link,
+				Group:  group,
+				Prefix: "",
+				// Patterns with overlapping prefixes - order should not matter due to sorting fix
+				ShardingPattern: []string{
+					`a_?`,   // shortest, matches a_1, a_2 but also a_b_1, a_c_1 without fix
+					`a_b_?`, // longer, should match a_b_1, a_b_2
+					`a_c_?`, // longer, should match a_c_1, a_c_2
+				},
+			}
+		)
+		err = gutil.FillStructWithDefault(&in)
+		t.AssertNil(err)
+
+		err = gfile.Mkdir(path)
+		t.AssertNil(err)
+
+		pwd := gfile.Pwd()
+		err = gfile.Chdir(path)
+		t.AssertNil(err)
+		defer gfile.Chdir(pwd)
+		defer gfile.RemoveAll(path)
+
+		_, err = gendao.CGenDao{}.Dao(ctx, in)
+		t.AssertNil(err)
+
+		// Should generate 3 dao files: a.go, a_b.go, a_c.go (plus internal versions)
+		generatedFiles, err := gfile.ScanDir(path, "*.go", true)
+		t.AssertNil(err)
+		// 3 sharding groups * 4 files each (dao, internal, do, entity) = 12 files
+		t.Assert(len(generatedFiles), 12)
+
+		var (
+			daoAContent  = gfile.GetContents(gfile.Join(path, "dao", "a.go"))
+			daoABContent = gfile.GetContents(gfile.Join(path, "dao", "a_b.go"))
+			daoACContent = gfile.GetContents(gfile.Join(path, "dao", "a_c.go"))
+		)
+
+		// Verify each sharding group has correct dao file generated
+		t.Assert(gstr.Contains(daoAContent, "aShardingHandler"), true)
+		t.Assert(gstr.Contains(daoAContent, "m.Sharding(gdb.ShardingConfig{"), true)
+
+		t.Assert(gstr.Contains(daoABContent, "aBShardingHandler"), true)
+		t.Assert(gstr.Contains(daoABContent, "m.Sharding(gdb.ShardingConfig{"), true)
+
+		t.Assert(gstr.Contains(daoACContent, "aCShardingHandler"), true)
+		t.Assert(gstr.Contains(daoACContent, "m.Sharding(gdb.ShardingConfig{"), true)
+	})
+}
+
 func Test_Gen_Dao_Sharding(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		var (

cmd/gf/internal/cmd/cmd_z_unit_gen_enums_test.go

@@ -0,0 +1,158 @@
+// Copyright GoFrame gf Author(https://goframe.org). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package cmd
+
+import (
+	"path/filepath"
+	"testing"
+
+	"github.com/gogf/gf/v2/os/gfile"
+	"github.com/gogf/gf/v2/test/gtest"
+	"github.com/gogf/gf/v2/util/guid"
+	"github.com/gogf/gf/v2/util/gutil"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/genenums"
+)
+
+// https://github.com/gogf/gf/issues/4387
+// Test that the output path is relative to the original working directory,
+// not the source directory after Chdir.
+func Test_Gen_Enums_Issue4387_RelativePath(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			// Create temp directory to simulate user's project
+			tempPath = gfile.Temp(guid.S())
+			// Copy testdata to temp directory
+			srcTestData = gtest.DataPath("issue", "4387")
+		)
+
+		// Setup: create temp project structure
+		err := gfile.CopyDir(srcTestData, tempPath)
+		t.AssertNil(err)
+		defer gfile.Remove(tempPath)
+
+		// Save original working directory
+		originalWd := gfile.Pwd()
+
+		// Change to temp directory (simulate user being in project root)
+		err = gfile.Chdir(tempPath)
+		t.AssertNil(err)
+		defer gfile.Chdir(originalWd) // Restore original working directory
+
+		// Run gen enums with relative paths
+		var (
+			srcFolder  = "api"
+			outputPath = filepath.FromSlash("internal/packed/packed_enums.go")
+			in         = genenums.CGenEnumsInput{
+				Src:  srcFolder,
+				Path: outputPath,
+			}
+		)
+		err = gutil.FillStructWithDefault(&in)
+		t.AssertNil(err)
+
+		_, err = genenums.CGenEnums{}.Enums(ctx, in)
+		t.AssertNil(err)
+
+		// Expected: file should be created at tempPath/internal/packed/packed_enums.go
+		expectedPath := filepath.Join(tempPath, "internal", "packed", "packed_enums.go")
+		// Bug: file is created at tempPath/api/internal/packed/packed_enums.go
+		wrongPath := filepath.Join(tempPath, "api", "internal", "packed", "packed_enums.go")
+
+		// Assert the file is at the expected location
+		t.Assert(gfile.Exists(expectedPath), true)
+		// Assert the file is NOT at the wrong location
+		t.Assert(gfile.Exists(wrongPath), false)
+	})
+}
+
+// Test gen enums with absolute output path (should work correctly)
+func Test_Gen_Enums_AbsolutePath(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			tempPath    = gfile.Temp(guid.S())
+			srcTestData = gtest.DataPath("issue", "4387")
+		)
+
+		err := gfile.CopyDir(srcTestData, tempPath)
+		t.AssertNil(err)
+		defer gfile.Remove(tempPath)
+
+		originalWd := gfile.Pwd()
+		err = gfile.Chdir(tempPath)
+		t.AssertNil(err)
+		defer gfile.Chdir(originalWd)
+
+		// Use absolute path for output
+		var (
+			srcFolder  = "api"
+			outputPath = filepath.Join(tempPath, "internal", "packed", "packed_enums.go")
+			in         = genenums.CGenEnumsInput{
+				Src:  srcFolder,
+				Path: outputPath,
+			}
+		)
+		err = gutil.FillStructWithDefault(&in)
+		t.AssertNil(err)
+
+		_, err = genenums.CGenEnums{}.Enums(ctx, in)
+		t.AssertNil(err)
+
+		// Assert the file exists at absolute path
+		t.Assert(gfile.Exists(outputPath), true)
+	})
+}
+
+// Test gen enums in monorepo mode (cd app/xxx/ then run command)
+func Test_Gen_Enums_Issue4387_Monorepo(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			// Simulate monorepo structure
+			tempPath    = gfile.Temp(guid.S())
+			srcTestData = gtest.DataPath("issue", "4387")
+			// app/myapp is the subdirectory in monorepo
+			appPath = filepath.Join(tempPath, "app", "myapp")
+		)
+
+		// Create monorepo structure: tempPath/app/myapp/api/...
+		err := gfile.Mkdir(appPath)
+		t.AssertNil(err)
+		// Copy testdata into app/myapp
+		err = gfile.CopyDir(srcTestData, appPath)
+		t.AssertNil(err)
+		defer gfile.Remove(tempPath)
+
+		originalWd := gfile.Pwd()
+
+		// cd app/myapp (simulate user in monorepo subdirectory)
+		err = gfile.Chdir(appPath)
+		t.AssertNil(err)
+		defer gfile.Chdir(originalWd)
+
+		var (
+			srcFolder  = "api"
+			outputPath = filepath.FromSlash("internal/packed/packed_enums.go")
+			in         = genenums.CGenEnumsInput{
+				Src:  srcFolder,
+				Path: outputPath,
+			}
+		)
+		err = gutil.FillStructWithDefault(&in)
+		t.AssertNil(err)
+
+		_, err = genenums.CGenEnums{}.Enums(ctx, in)
+		t.AssertNil(err)
+
+		// Expected: file at app/myapp/internal/packed/packed_enums.go
+		expectedPath := filepath.Join(appPath, "internal", "packed", "packed_enums.go")
+		// Bug: file at app/myapp/api/internal/packed/packed_enums.go
+		wrongPath := filepath.Join(appPath, "api", "internal", "packed", "packed_enums.go")
+
+		t.Assert(gfile.Exists(expectedPath), true)
+		t.Assert(gfile.Exists(wrongPath), false)
+	})
+}

cmd/gf/internal/cmd/cmd_z_unit_gen_pb_test.go

@@ -88,3 +88,76 @@ func TestGenPbIssue3953(t *testing.T) {
 		t.Assert(gstr.Contains(genContent, notExceptText), false)
 	})
 }
+
+func TestGenPb_MultipleTags(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			outputPath     = gfile.Temp(guid.S())
+			outputApiPath  = filepath.Join(outputPath, "api")
+			outputCtrlPath = filepath.Join(outputPath, "controller")
+
+			protobufFolder = gtest.DataPath("genpb")
+			in             = genpb.CGenPbInput{
+				Path:       protobufFolder,
+				OutputApi:  outputApiPath,
+				OutputCtrl: outputCtrlPath,
+			}
+			err error
+		)
+		err = gfile.Mkdir(outputApiPath)
+		t.AssertNil(err)
+		err = gfile.Mkdir(outputCtrlPath)
+		t.AssertNil(err)
+		defer gfile.Remove(outputPath)
+
+		_, err = genpb.CGenPb{}.Pb(ctx, in)
+		t.AssertNil(err)
+
+		// Test multiple_tags.proto output
+		genContent := gfile.GetContents(filepath.Join(outputApiPath, "multiple_tags.pb.go"))
+		// Id field should have combined validation tags: v:"required#Id > 0"
+		t.Assert(gstr.Contains(genContent, `v:"required#Id > 0"`), true)
+		// Name field should have dc tag from plain comment
+		t.Assert(gstr.Contains(genContent, `dc:"User name for login"`), true)
+		// Email field should have combined validation and dc tag
+		t.Assert(gstr.Contains(genContent, `v:"requiredemail"`), true)
+		t.Assert(gstr.Contains(genContent, `dc:"User email address"`), true)
+	})
+}
+
+func TestGenPb_NestedMessage(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			outputPath     = gfile.Temp(guid.S())
+			outputApiPath  = filepath.Join(outputPath, "api")
+			outputCtrlPath = filepath.Join(outputPath, "controller")
+
+			protobufFolder = gtest.DataPath("genpb")
+			in             = genpb.CGenPbInput{
+				Path:       protobufFolder,
+				OutputApi:  outputApiPath,
+				OutputCtrl: outputCtrlPath,
+			}
+			err error
+		)
+		err = gfile.Mkdir(outputApiPath)
+		t.AssertNil(err)
+		err = gfile.Mkdir(outputCtrlPath)
+		t.AssertNil(err)
+		defer gfile.Remove(outputPath)
+
+		_, err = genpb.CGenPb{}.Pb(ctx, in)
+		t.AssertNil(err)
+
+		// Test nested_message.proto output
+		genContent := gfile.GetContents(filepath.Join(outputApiPath, "nested_message.pb.go"))
+		// Order.OrderId should have v:"required"
+		t.Assert(gstr.Contains(genContent, `v:"required"`), true)
+		// Order.Detail should have dc:"Order details"
+		t.Assert(gstr.Contains(genContent, `dc:"Order details"`), true)
+		// OrderDetail.Quantity should have v:"min:1"
+		t.Assert(gstr.Contains(genContent, `v:"min:1"`), true)
+		// OrderDetail.Price should have v:"min:0.01"
+		t.Assert(gstr.Contains(genContent, `v:"min:0.01"`), true)
+	})
+}

cmd/gf/internal/cmd/cmd_z_unit_gen_service_test.go

@@ -156,3 +156,130 @@ func Test_Issue3835(t *testing.T) {
 		t.Assert(gfile.GetContents(genFile), gfile.GetContents(expectFile))
 	})
 }
+
+func Test_Gen_Service_CamelCase(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			path      = gfile.Temp(guid.S())
+			dstFolder = path + filepath.FromSlash("/service")
+			srvFolder = gtest.DataPath("genservice", "logic")
+			in        = genservice.CGenServiceInput{
+				SrcFolder:       srvFolder,
+				DstFolder:       dstFolder,
+				DstFileNameCase: "Camel",
+				WatchFile:       "",
+				StPattern:       "",
+				Packages:        nil,
+				ImportPrefix:    "",
+				Clear:           false,
+			}
+		)
+		err := gutil.FillStructWithDefault(&in)
+		t.AssertNil(err)
+
+		err = gfile.Mkdir(path)
+		t.AssertNil(err)
+		defer gfile.Remove(path)
+
+		// Clean up generated logic.go
+		genSrv := srvFolder + filepath.FromSlash("/logic.go")
+		defer gfile.Remove(genSrv)
+
+		_, err = genservice.CGenService{}.Service(ctx, in)
+		t.AssertNil(err)
+
+		// Files should be in CamelCase
+		files, err := gfile.ScanDir(dstFolder, "*.go", true)
+		t.AssertNil(err)
+		t.Assert(files, []string{
+			dstFolder + filepath.FromSlash("/Article.go"),
+			dstFolder + filepath.FromSlash("/Base.go"),
+			dstFolder + filepath.FromSlash("/Delivery.go"),
+			dstFolder + filepath.FromSlash("/User.go"),
+		})
+	})
+}
+
+func Test_Gen_Service_PackagesFilter(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			path      = gfile.Temp(guid.S())
+			dstFolder = path + filepath.FromSlash("/service")
+			srvFolder = gtest.DataPath("genservice", "logic")
+			in        = genservice.CGenServiceInput{
+				SrcFolder:       srvFolder,
+				DstFolder:       dstFolder,
+				DstFileNameCase: "Snake",
+				WatchFile:       "",
+				StPattern:       "",
+				Packages:        []string{"user"},
+				ImportPrefix:    "",
+				Clear:           false,
+			}
+		)
+		err := gutil.FillStructWithDefault(&in)
+		t.AssertNil(err)
+
+		err = gfile.Mkdir(path)
+		t.AssertNil(err)
+		defer gfile.Remove(path)
+
+		// Clean up generated logic.go
+		genSrv := srvFolder + filepath.FromSlash("/logic.go")
+		defer gfile.Remove(genSrv)
+
+		_, err = genservice.CGenService{}.Service(ctx, in)
+		t.AssertNil(err)
+
+		// Only user.go should be generated
+		files, err := gfile.ScanDir(dstFolder, "*.go", true)
+		t.AssertNil(err)
+		t.Assert(len(files), 1)
+		t.Assert(files[0], dstFolder+filepath.FromSlash("/user.go"))
+	})
+}
+
+// https://github.com/gogf/gf/issues/4242
+// Test that versioned imports and aliased imports are correctly preserved.
+// The issue is that imports like "github.com/minio/minio-go/v7" were being
+// incorrectly handled because the package name (minio) differs from
+// the directory name (minio-go).
+func Test_Issue4242(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			path      = gfile.Temp(guid.S())
+			dstFolder = path + filepath.FromSlash("/service")
+			srvFolder = gtest.DataPath("issue", "4242", "logic")
+			in        = genservice.CGenServiceInput{
+				SrcFolder:       srvFolder,
+				DstFolder:       dstFolder,
+				DstFileNameCase: "Snake",
+				WatchFile:       "",
+				StPattern:       "",
+				Packages:        nil,
+				ImportPrefix:    "",
+				Clear:           false,
+			}
+		)
+		err := gutil.FillStructWithDefault(&in)
+		t.AssertNil(err)
+
+		err = gfile.Mkdir(path)
+		t.AssertNil(err)
+		defer gfile.Remove(path)
+
+		_, err = genservice.CGenService{}.Service(ctx, in)
+		t.AssertNil(err)
+
+		// Test versioned imports
+		t.Assert(
+			gfile.GetContents(dstFolder+filepath.FromSlash("/issue_4242.go")),
+			gfile.GetContents(gtest.DataPath("issue", "4242", "service", "issue_4242.go")),
+		)
+		// Test aliased imports
+		t.Assert(
+			gfile.GetContents(dstFolder+filepath.FromSlash("/issue_4242_alias.go")),
+			gfile.GetContents(gtest.DataPath("issue", "4242", "service", "issue_4242_alias.go")),
+		)
+	})
+}

cmd/gf/internal/cmd/cmd_z_unit_pack_test.go

@@ -0,0 +1,346 @@
+// Copyright GoFrame gf Author(https://goframe.org). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package cmd
+
+import (
+	"context"
+	"path/filepath"
+	"testing"
+
+	"github.com/gogf/gf/v2/os/gfile"
+	"github.com/gogf/gf/v2/test/gtest"
+	"github.com/gogf/gf/v2/text/gstr"
+	"github.com/gogf/gf/v2/util/guid"
+)
+
+func Test_Pack_ToGoFile(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			srcPath = gfile.Temp(guid.S())
+			dstPath = gfile.Temp(guid.S())
+			dstFile = filepath.Join(dstPath, "packed", "data.go")
+		)
+		// Create source directory with test files
+		err := gfile.Mkdir(srcPath)
+		t.AssertNil(err)
+		defer gfile.Remove(srcPath)
+
+		err = gfile.Mkdir(dstPath)
+		t.AssertNil(err)
+		defer gfile.Remove(dstPath)
+
+		// Create test files
+		err = gfile.PutContents(filepath.Join(srcPath, "test.txt"), "hello world")
+		t.AssertNil(err)
+		err = gfile.PutContents(filepath.Join(srcPath, "test.json"), `{"key":"value"}`)
+		t.AssertNil(err)
+
+		// Create packed directory
+		err = gfile.Mkdir(filepath.Join(dstPath, "packed"))
+		t.AssertNil(err)
+
+		// Pack to go file
+		_, err = Pack.Index(context.Background(), cPackInput{
+			Src:  srcPath,
+			Dst:  dstFile,
+			Name: "packed",
+		})
+		t.AssertNil(err)
+
+		// Verify output file exists
+		t.Assert(gfile.Exists(dstFile), true)
+
+		// Verify it's a valid Go file
+		content := gfile.GetContents(dstFile)
+		t.Assert(gstr.Contains(content, "package packed"), true)
+		t.Assert(gstr.Contains(content, "func init()"), true)
+	})
+}
+
+func Test_Pack_ToBinaryFile(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			srcPath = gfile.Temp(guid.S())
+			dstPath = gfile.Temp(guid.S())
+			dstFile = filepath.Join(dstPath, "data.bin")
+		)
+		// Create source directory with test files
+		err := gfile.Mkdir(srcPath)
+		t.AssertNil(err)
+		defer gfile.Remove(srcPath)
+
+		err = gfile.Mkdir(dstPath)
+		t.AssertNil(err)
+		defer gfile.Remove(dstPath)
+
+		// Create test file
+		err = gfile.PutContents(filepath.Join(srcPath, "test.txt"), "binary content")
+		t.AssertNil(err)
+
+		// Pack to binary file (no Name specified)
+		_, err = Pack.Index(context.Background(), cPackInput{
+			Src: srcPath,
+			Dst: dstFile,
+		})
+		t.AssertNil(err)
+
+		// Verify output file exists
+		t.Assert(gfile.Exists(dstFile), true)
+
+		// Verify it's a binary file (not a Go file)
+		content := gfile.GetContents(dstFile)
+		t.Assert(gstr.Contains(content, "package"), false)
+	})
+}
+
+func Test_Pack_MultipleSources(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			srcPath1 = gfile.Temp(guid.S())
+			srcPath2 = gfile.Temp(guid.S())
+			dstPath  = gfile.Temp(guid.S())
+			dstFile  = filepath.Join(dstPath, "packed", "multi.go")
+		)
+		// Create source directories
+		err := gfile.Mkdir(srcPath1)
+		t.AssertNil(err)
+		defer gfile.Remove(srcPath1)
+
+		err = gfile.Mkdir(srcPath2)
+		t.AssertNil(err)
+		defer gfile.Remove(srcPath2)
+
+		err = gfile.Mkdir(dstPath)
+		t.AssertNil(err)
+		defer gfile.Remove(dstPath)
+
+		// Create test files in each source
+		err = gfile.PutContents(filepath.Join(srcPath1, "file1.txt"), "content1")
+		t.AssertNil(err)
+		err = gfile.PutContents(filepath.Join(srcPath2, "file2.txt"), "content2")
+		t.AssertNil(err)
+
+		// Create packed directory
+		err = gfile.Mkdir(filepath.Join(dstPath, "packed"))
+		t.AssertNil(err)
+
+		// Pack multiple sources (comma-separated)
+		_, err = Pack.Index(context.Background(), cPackInput{
+			Src:  srcPath1 + "," + srcPath2,
+			Dst:  dstFile,
+			Name: "packed",
+		})
+		t.AssertNil(err)
+
+		// Verify output file exists
+		t.Assert(gfile.Exists(dstFile), true)
+	})
+}
+
+func Test_Pack_WithPrefix(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			srcPath = gfile.Temp(guid.S())
+			dstPath = gfile.Temp(guid.S())
+			dstFile = filepath.Join(dstPath, "packed", "prefix.go")
+		)
+		// Create source directory
+		err := gfile.Mkdir(srcPath)
+		t.AssertNil(err)
+		defer gfile.Remove(srcPath)
+
+		err = gfile.Mkdir(dstPath)
+		t.AssertNil(err)
+		defer gfile.Remove(dstPath)
+
+		// Create test file
+		err = gfile.PutContents(filepath.Join(srcPath, "test.txt"), "with prefix")
+		t.AssertNil(err)
+
+		// Create packed directory
+		err = gfile.Mkdir(filepath.Join(dstPath, "packed"))
+		t.AssertNil(err)
+
+		// Pack with prefix
+		_, err = Pack.Index(context.Background(), cPackInput{
+			Src:    srcPath,
+			Dst:    dstFile,
+			Name:   "packed",
+			Prefix: "/static",
+		})
+		t.AssertNil(err)
+
+		// Verify output file exists
+		t.Assert(gfile.Exists(dstFile), true)
+	})
+}
+
+func Test_Pack_WithKeepPath(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			srcPath = gfile.Temp(guid.S())
+			dstPath = gfile.Temp(guid.S())
+			dstFile = filepath.Join(dstPath, "packed", "keeppath.go")
+		)
+		// Create source directory with subdirectory
+		err := gfile.Mkdir(srcPath)
+		t.AssertNil(err)
+		defer gfile.Remove(srcPath)
+
+		err = gfile.Mkdir(dstPath)
+		t.AssertNil(err)
+		defer gfile.Remove(dstPath)
+
+		// Create subdirectory and file
+		subDir := filepath.Join(srcPath, "subdir")
+		err = gfile.Mkdir(subDir)
+		t.AssertNil(err)
+		err = gfile.PutContents(filepath.Join(subDir, "test.txt"), "keeppath content")
+		t.AssertNil(err)
+
+		// Create packed directory
+		err = gfile.Mkdir(filepath.Join(dstPath, "packed"))
+		t.AssertNil(err)
+
+		// Pack with keepPath
+		_, err = Pack.Index(context.Background(), cPackInput{
+			Src:      srcPath,
+			Dst:      dstFile,
+			Name:     "packed",
+			KeepPath: true,
+		})
+		t.AssertNil(err)
+
+		// Verify output file exists
+		t.Assert(gfile.Exists(dstFile), true)
+	})
+}
+
+func Test_Pack_AutoPackageName(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			srcPath = gfile.Temp(guid.S())
+			dstPath = gfile.Temp(guid.S())
+			dstFile = filepath.Join(dstPath, "mypackage", "data.go")
+		)
+		// Create source directory
+		err := gfile.Mkdir(srcPath)
+		t.AssertNil(err)
+		defer gfile.Remove(srcPath)
+
+		err = gfile.Mkdir(dstPath)
+		t.AssertNil(err)
+		defer gfile.Remove(dstPath)
+
+		// Create test file
+		err = gfile.PutContents(filepath.Join(srcPath, "test.txt"), "auto package name")
+		t.AssertNil(err)
+
+		// Create mypackage directory
+		err = gfile.Mkdir(filepath.Join(dstPath, "mypackage"))
+		t.AssertNil(err)
+
+		// Pack without Name - should use directory name "mypackage"
+		_, err = Pack.Index(context.Background(), cPackInput{
+			Src: srcPath,
+			Dst: dstFile,
+			// Name not specified, should be auto-detected as "mypackage"
+		})
+		t.AssertNil(err)
+
+		// Verify output file exists and has correct package name
+		t.Assert(gfile.Exists(dstFile), true)
+		content := gfile.GetContents(dstFile)
+		t.Assert(gstr.Contains(content, "package mypackage"), true)
+	})
+}
+
+func Test_Pack_EmptySource(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			srcPath = gfile.Temp(guid.S())
+			dstPath = gfile.Temp(guid.S())
+			dstFile = filepath.Join(dstPath, "packed", "empty.go")
+		)
+		// Create empty source directory
+		err := gfile.Mkdir(srcPath)
+		t.AssertNil(err)
+		defer gfile.Remove(srcPath)
+
+		err = gfile.Mkdir(dstPath)
+		t.AssertNil(err)
+		defer gfile.Remove(dstPath)
+
+		// Create packed directory
+		err = gfile.Mkdir(filepath.Join(dstPath, "packed"))
+		t.AssertNil(err)
+
+		// Pack empty directory
+		_, err = Pack.Index(context.Background(), cPackInput{
+			Src:  srcPath,
+			Dst:  dstFile,
+			Name: "packed",
+		})
+		t.AssertNil(err)
+
+		// Verify output file exists (even if source is empty)
+		t.Assert(gfile.Exists(dstFile), true)
+	})
+}
+
+func Test_Pack_NestedDirectories(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			srcPath = gfile.Temp(guid.S())
+			dstPath = gfile.Temp(guid.S())
+			dstFile = filepath.Join(dstPath, "packed", "nested.go")
+		)
+		// Create source directory with nested structure
+		err := gfile.Mkdir(srcPath)
+		t.AssertNil(err)
+		defer gfile.Remove(srcPath)
+
+		err = gfile.Mkdir(dstPath)
+		t.AssertNil(err)
+		defer gfile.Remove(dstPath)
+
+		// Create nested directories and files
+		level1 := filepath.Join(srcPath, "level1")
+		level2 := filepath.Join(level1, "level2")
+		level3 := filepath.Join(level2, "level3")
+		err = gfile.Mkdir(level3)
+		t.AssertNil(err)
+
+		err = gfile.PutContents(filepath.Join(srcPath, "root.txt"), "root")
+		t.AssertNil(err)
+		err = gfile.PutContents(filepath.Join(level1, "l1.txt"), "level1")
+		t.AssertNil(err)
+		err = gfile.PutContents(filepath.Join(level2, "l2.txt"), "level2")
+		t.AssertNil(err)
+		err = gfile.PutContents(filepath.Join(level3, "l3.txt"), "level3")
+		t.AssertNil(err)
+
+		// Create packed directory
+		err = gfile.Mkdir(filepath.Join(dstPath, "packed"))
+		t.AssertNil(err)
+
+		// Pack nested directories
+		_, err = Pack.Index(context.Background(), cPackInput{
+			Src:  srcPath,
+			Dst:  dstFile,
+			Name: "packed",
+		})
+		t.AssertNil(err)
+
+		// Verify output file exists
+		t.Assert(gfile.Exists(dstFile), true)
+
+		// Verify content includes all files
+		content := gfile.GetContents(dstFile)
+		t.Assert(gstr.Contains(content, "package packed"), true)
+	})
+}

cmd/gf/internal/cmd/genctrl/genctrl.go

@@ -89,28 +89,11 @@ func (c CGenCtrl) Ctrl(ctx context.Context, in CGenCtrlInput) (out *CGenCtrlOutp
 	if !gfile.Exists(in.SrcFolder) {
 		mlog.Fatalf(`source folder path "%s" does not exist`, in.SrcFolder)
 	}
-	// retrieve all api modules.
-	apiModuleFolderPaths, err := gfile.ScanDir(in.SrcFolder, "*", false)
+
+	err = c.generateByModules(in)
 	if err != nil {
 		return nil, err
 	}
-	for _, apiModuleFolderPath := range apiModuleFolderPaths {
-		if !gfile.IsDir(apiModuleFolderPath) {
-			continue
-		}
-		// generate go files by api module.
-		var (
-			module              = gfile.Basename(apiModuleFolderPath)
-			dstModuleFolderPath = gfile.Join(in.DstFolder, module)
-		)
-		err = c.generateByModule(
-			apiModuleFolderPath, dstModuleFolderPath, in.SdkPath,
-			in.SdkStdVersion, in.SdkNoV1, in.Clear, in.Merge,
-		)
-		if err != nil {
-			return nil, err
-		}
-	}
 
 	mlog.Print(`done!`)
 	return
@@ -163,6 +146,56 @@ func (c CGenCtrl) generateByWatchFile(watchFile, sdkPath string, sdkStdVersion,
 	)
 }
 
+// generateByModules recursively calls generateByModule for multi-level modules generation.
+func (c CGenCtrl) generateByModules(in CGenCtrlInput) (err error) {
+	// read root folder, example: api/user or api/app
+	moduleFolderPaths, err := gfile.ScanDir(in.SrcFolder, "*", false)
+	if err != nil {
+		return err
+	}
+	for _, moduleFolder := range moduleFolderPaths {
+		if !gfile.IsDir(moduleFolder) {
+			continue
+		}
+
+		// read children folder, example: api/user/v1 or api/app/user
+		childrenFolderPaths, err := gfile.ScanDir(moduleFolder, "*", false)
+		if err != nil {
+			return err
+		}
+		for _, childrenFolderPath := range childrenFolderPaths {
+			if !gfile.IsDir(childrenFolderPath) {
+				continue
+			}
+
+			var (
+				inCopy = in
+				module = gfile.Basename(moduleFolder)
+			)
+			inCopy.SrcFolder = gfile.Join(in.SrcFolder, module)
+			inCopy.DstFolder = gfile.Join(in.DstFolder, module)
+			err = c.generateByModules(inCopy)
+			if err != nil {
+				return err
+			}
+		}
+
+		// generate go files by api module.
+		var (
+			module              = gfile.Basename(moduleFolder)
+			dstModuleFolderPath = gfile.Join(in.DstFolder, module)
+		)
+		err = c.generateByModule(
+			moduleFolder, dstModuleFolderPath, in.SdkPath,
+			in.SdkStdVersion, in.SdkNoV1, in.Clear, in.Merge,
+		)
+		if err != nil {
+			return err
+		}
+	}
+	return
+}
+
 // parseApiModule parses certain api and generate associated go files by certain module, not all api modules.
 func (c CGenCtrl) generateByModule(
 	apiModuleFolderPath, dstModuleFolderPath, sdkPath string,

cmd/gf/internal/cmd/genctrl/genctrl_generate_ctrl.go

@@ -8,6 +8,9 @@ package genctrl
 
 import (
 	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
 	"path/filepath"
 	"strings"
 
@@ -144,8 +147,8 @@ func (c *controllerGenerator) doGenerateCtrlItem(dstModuleFolderPath string, ite
 			"{MethodName}":    item.MethodName,
 			"{MethodComment}": item.GetComment(),
 		})
-
-		if gstr.Contains(gfile.GetContents(methodFilePath), fmt.Sprintf(`func (c *%v) %v(`, ctrlName, item.MethodName)) {
+		// Use AST-based checking for more accurate method detection
+		if methodExists(methodFilePath, ctrlName, item.MethodName) {
 			return
 		}
 		if err = gfile.PutContentsAppend(methodFilePath, gstr.TrimLeft(content)); err != nil {
@@ -170,7 +173,6 @@ func (c *controllerGenerator) doGenerateCtrlItem(dstModuleFolderPath string, ite
 
 // use -merge
 func (c *controllerGenerator) doGenerateCtrlMergeItem(dstModuleFolderPath string, apiItems []apiItem, doneApiSet *gset.StrSet) (err error) {
-
 	type controllerFileItem struct {
 		module     string
 		version    string
@@ -193,13 +195,23 @@ func (c *controllerGenerator) doGenerateCtrlMergeItem(dstModuleFolderPath string
 			ctrlFileItemMap[api.FileName] = ctrlFileItem
 		}
 
+		ctrlName := fmt.Sprintf(`Controller%s`, gstr.UcFirst(api.Version))
 		ctrl := gstr.TrimLeft(gstr.ReplaceByMap(consts.TemplateGenCtrlControllerMethodFuncMerge, g.MapStrStr{
 			"{Module}":        api.Module,
-			"{CtrlName}":      fmt.Sprintf(`Controller%s`, gstr.UcFirst(api.Version)),
+			"{CtrlName}":      ctrlName,
 			"{Version}":       api.Version,
 			"{MethodName}":    api.MethodName,
 			"{MethodComment}": api.GetComment(),
 		}))
+
+		ctrlFilePath := gfile.Join(dstModuleFolderPath, fmt.Sprintf(
+			`%s_%s_%s.go`, ctrlFileItem.module, ctrlFileItem.version, api.FileName,
+		))
+		// Use AST-based checking for more accurate method detection
+		if methodExists(ctrlFilePath, ctrlName, api.MethodName) {
+			return
+		}
+
 		ctrlFileItem.controllers.WriteString(ctrl)
 		doneApiSet.Add(api.String())
 	}
@@ -229,3 +241,41 @@ func (c *controllerGenerator) doGenerateCtrlMergeItem(dstModuleFolderPath string
 	}
 	return
 }
+
+// methodExists checks if a method with the given receiver type and name exists in the file.
+// It uses AST parsing to accurately detect method definitions regardless of formatting.
+// This handles various code formatting styles including multi-line method signatures.
+func methodExists(filePath, ctrlName, methodName string) bool {
+	fset := token.NewFileSet()
+	node, err := parser.ParseFile(fset, filePath, nil, parser.ParseComments)
+	if err != nil {
+		// If parsing fails (e.g., file doesn't exist or invalid syntax), return false
+		return false
+	}
+	for _, decl := range node.Decls {
+		funcDecl, ok := decl.(*ast.FuncDecl)
+		if !ok {
+			continue
+		}
+		// Check if it's a method (has receiver)
+		if funcDecl.Recv != nil && len(funcDecl.Recv.List) > 0 {
+			// Extract receiver type name
+			// Handle both *T and T patterns
+			recvType := ""
+			switch t := funcDecl.Recv.List[0].Type.(type) {
+			case *ast.StarExpr:
+				if ident, ok := t.X.(*ast.Ident); ok {
+					recvType = ident.Name
+				}
+			case *ast.Ident:
+				recvType = t.Name
+			}
+
+			// Check if both receiver type and method name match
+			if recvType == ctrlName && funcDecl.Name.Name == methodName {
+				return true
+			}
+		}
+	}
+	return false
+}

cmd/gf/internal/cmd/gendao/gendao.go

@@ -9,6 +9,7 @@ package gendao
 import (
 	"context"
 	"fmt"
+	"sort"
 	"strings"
 
 	"github.com/olekukonko/tablewriter"
@@ -187,7 +188,27 @@ func doGenDaoForArray(ctx context.Context, index int, in CGenDaoInput) {
 
 	var tableNames []string
 	if in.Tables != "" {
-		tableNames = gstr.SplitAndTrim(in.Tables, ",")
+		inputTables := gstr.SplitAndTrim(in.Tables, ",")
+		// Check if any table pattern contains wildcard characters.
+		// https://github.com/gogf/gf/issues/4629
+		var hasPattern bool
+		for _, t := range inputTables {
+			if containsWildcard(t) {
+				hasPattern = true
+				break
+			}
+		}
+		if hasPattern {
+			// Fetch all tables first, then filter by patterns.
+			allTables, err := db.Tables(context.TODO())
+			if err != nil {
+				mlog.Fatalf("fetching tables failed: %+v", err)
+			}
+			tableNames = filterTablesByPatterns(allTables, inputTables)
+		} else {
+			// Use exact table names as before.
+			tableNames = inputTables
+		}
 	} else {
 		tableNames, err = db.Tables(context.TODO())
 		if err != nil {
@@ -198,22 +219,11 @@ func doGenDaoForArray(ctx context.Context, index int, in CGenDaoInput) {
 	if in.TablesEx != "" {
 		array := garray.NewStrArrayFrom(tableNames)
 		for _, p := range gstr.SplitAndTrim(in.TablesEx, ",") {
-			if gstr.Contains(p, "*") || gstr.Contains(p, "?") {
-				p = gstr.ReplaceByMap(p, map[string]string{
-					"\r": "",
-					"\n": "",
-				})
-				p = gstr.ReplaceByMap(p, map[string]string{
-					"*": "\r",
-					"?": "\n",
-				})
-				p = gregex.Quote(p)
-				p = gstr.ReplaceByMap(p, map[string]string{
-					"\r": ".*",
-					"\n": ".",
-				})
+			if containsWildcard(p) {
+				// Use exact match with ^ and $ anchors for consistency with tables pattern.
+				regPattern := "^" + patternToRegex(p) + "$"
 				for _, v := range array.Clone().Slice() {
-					if gregex.IsMatchString(p, v) {
+					if gregex.IsMatchString(regPattern, v) {
 						array.RemoveValue(v)
 					}
 				}
@@ -240,13 +250,22 @@ func doGenDaoForArray(ctx context.Context, index int, in CGenDaoInput) {
 		newTableNames       = make([]string, len(tableNames))
 		shardingNewTableSet = gset.NewStrSet()
 	)
+	// Sort sharding patterns by length descending, so that longer (more specific) patterns
+	// are matched first. This prevents shorter patterns like "a_?" from incorrectly matching
+	// tables that should match longer patterns like "a_b_?" or "a_c_?".
+	// https://github.com/gogf/gf/issues/4603
+	sortedShardingPatterns := make([]string, len(in.ShardingPattern))
+	copy(sortedShardingPatterns, in.ShardingPattern)
+	sort.Slice(sortedShardingPatterns, func(i, j int) bool {
+		return len(sortedShardingPatterns[i]) > len(sortedShardingPatterns[j])
+	})
 	for i, tableName := range tableNames {
 		newTableName := tableName
 		for _, v := range removePrefixArray {
 			newTableName = gstr.TrimLeftStr(newTableName, v, 1)
 		}
-		if len(in.ShardingPattern) > 0 {
-			for _, pattern := range in.ShardingPattern {
+		if len(sortedShardingPatterns) > 0 {
+			for _, pattern := range sortedShardingPatterns {
 				var (
 					match      []string
 					regPattern = gstr.Replace(pattern, "?", `(.+)`)
@@ -262,10 +281,11 @@ func doGenDaoForArray(ctx context.Context, index int, in CGenDaoInput) {
 				newTableName = gstr.Trim(newTableName, `_.-`)
 				if shardingNewTableSet.Contains(newTableName) {
 					tableNames[i] = ""
-					continue
+					break
 				}
 				// Add prefix to sharding table name, if not, the isSharding check would not match.
 				shardingNewTableSet.Add(in.Prefix + newTableName)
+				break
 			}
 		}
 		newTableName = in.Prefix + newTableName
@@ -411,3 +431,61 @@ func getTemplateFromPathOrDefault(filePath string, def string) string {
 	}
 	return def
 }
+
+// containsWildcard checks if the pattern contains wildcard characters (* or ?).
+func containsWildcard(pattern string) bool {
+	return gstr.Contains(pattern, "*") || gstr.Contains(pattern, "?")
+}
+
+// patternToRegex converts a wildcard pattern to a regex pattern.
+// Wildcard characters: * matches any characters, ? matches single character.
+func patternToRegex(pattern string) string {
+	pattern = gstr.ReplaceByMap(pattern, map[string]string{
+		"\r": "",
+		"\n": "",
+	})
+	pattern = gstr.ReplaceByMap(pattern, map[string]string{
+		"*": "\r",
+		"?": "\n",
+	})
+	pattern = gregex.Quote(pattern)
+	pattern = gstr.ReplaceByMap(pattern, map[string]string{
+		"\r": ".*",
+		"\n": ".",
+	})
+	return pattern
+}
+
+// filterTablesByPatterns filters tables by given patterns.
+// Patterns support wildcard characters: * matches any characters, ? matches single character.
+// https://github.com/gogf/gf/issues/4629
+func filterTablesByPatterns(allTables []string, patterns []string) []string {
+	var result []string
+	matched := make(map[string]bool)
+	allTablesSet := make(map[string]bool)
+	for _, t := range allTables {
+		allTablesSet[t] = true
+	}
+	for _, p := range patterns {
+		if containsWildcard(p) {
+			regPattern := "^" + patternToRegex(p) + "$"
+			for _, table := range allTables {
+				if !matched[table] && gregex.IsMatchString(regPattern, table) {
+					result = append(result, table)
+					matched[table] = true
+				}
+			}
+		} else {
+			// Exact table name, use direct string comparison.
+			if !allTablesSet[p] {
+				mlog.Printf(`table "%s" does not exist, skipped`, p)
+				continue
+			}
+			if !matched[p] {
+				result = append(result, p)
+				matched[p] = true
+			}
+		}
+	}
+	return result
+}

cmd/gf/internal/cmd/gendao/gendao_test.go

@@ -0,0 +1,182 @@
+// Copyright GoFrame gf Author(https://goframe.org). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gendao
+
+import (
+	"testing"
+
+	"github.com/gogf/gf/v2/test/gtest"
+)
+
+// Test containsWildcard function.
+func Test_containsWildcard(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		t.Assert(containsWildcard("trade_*"), true)
+		t.Assert(containsWildcard("user_?"), true)
+		t.Assert(containsWildcard("*"), true)
+		t.Assert(containsWildcard("?"), true)
+		t.Assert(containsWildcard("trade_order"), false)
+		t.Assert(containsWildcard(""), false)
+	})
+}
+
+// Test patternToRegex function.
+func Test_patternToRegex(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// * should become .*
+		t.Assert(patternToRegex("trade_*"), "trade_.*")
+		// ? should become .
+		t.Assert(patternToRegex("user_???"), "user_...")
+		// Mixed
+		t.Assert(patternToRegex("*_order_?"), ".*_order_.")
+		// No wildcards - should escape special regex chars
+		t.Assert(patternToRegex("trade_order"), "trade_order")
+		// Just *
+		t.Assert(patternToRegex("*"), ".*")
+	})
+}
+
+// Test filterTablesByPatterns with * wildcard.
+func Test_filterTablesByPatterns_Star(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		allTables := []string{"trade_order", "trade_item", "user_info", "user_log", "config"}
+
+		// Single pattern with *
+		result := filterTablesByPatterns(allTables, []string{"trade_*"})
+		t.Assert(len(result), 2)
+		t.AssertIN("trade_order", result)
+		t.AssertIN("trade_item", result)
+
+		// Multiple patterns with *
+		result = filterTablesByPatterns(allTables, []string{"trade_*", "user_*"})
+		t.Assert(len(result), 4)
+		t.AssertIN("trade_order", result)
+		t.AssertIN("trade_item", result)
+		t.AssertIN("user_info", result)
+		t.AssertIN("user_log", result)
+	})
+}
+
+// Test filterTablesByPatterns with ? wildcard.
+func Test_filterTablesByPatterns_Question(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		allTables := []string{"trade_order", "trade_item", "user_info", "user_log", "config"}
+
+		// ? matches single character: user_log (3 chars) but not user_info (4 chars)
+		result := filterTablesByPatterns(allTables, []string{"user_???"})
+		t.Assert(len(result), 1)
+		t.AssertIN("user_log", result)
+		t.AssertNI("user_info", result)
+
+		// user_???? should match user_info (4 chars)
+		result = filterTablesByPatterns(allTables, []string{"user_????"})
+		t.Assert(len(result), 1)
+		t.AssertIN("user_info", result)
+		t.AssertNI("user_log", result)
+	})
+}
+
+// Test filterTablesByPatterns with mixed patterns and exact names.
+func Test_filterTablesByPatterns_Mixed(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		allTables := []string{"trade_order", "trade_item", "user_info", "user_log", "config"}
+
+		// Pattern + exact name
+		result := filterTablesByPatterns(allTables, []string{"trade_*", "config"})
+		t.Assert(len(result), 3)
+		t.AssertIN("trade_order", result)
+		t.AssertIN("trade_item", result)
+		t.AssertIN("config", result)
+		t.AssertNI("user_info", result)
+		t.AssertNI("user_log", result)
+	})
+}
+
+// Test filterTablesByPatterns with exact names only (backward compatibility).
+func Test_filterTablesByPatterns_ExactNames(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		allTables := []string{"trade_order", "trade_item", "user_info", "user_log", "config"}
+
+		// Exact names only
+		result := filterTablesByPatterns(allTables, []string{"trade_order", "config"})
+		t.Assert(len(result), 2)
+		t.AssertIN("trade_order", result)
+		t.AssertIN("config", result)
+		t.AssertNI("trade_item", result)
+	})
+}
+
+// Test filterTablesByPatterns - no duplicates when table matches multiple patterns.
+func Test_filterTablesByPatterns_NoDuplicates(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		allTables := []string{"trade_order", "trade_item", "user_info"}
+
+		// trade_order matches both patterns, should only appear once
+		result := filterTablesByPatterns(allTables, []string{"trade_*", "trade_order"})
+		t.Assert(len(result), 2) // trade_order, trade_item
+
+		// Count occurrences of trade_order
+		count := 0
+		for _, v := range result {
+			if v == "trade_order" {
+				count++
+			}
+		}
+		t.Assert(count, 1) // No duplicates
+	})
+}
+
+// Test filterTablesByPatterns - pattern matches nothing.
+func Test_filterTablesByPatterns_NoMatch(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		allTables := []string{"trade_order", "trade_item", "user_info"}
+
+		// Pattern that matches nothing
+		result := filterTablesByPatterns(allTables, []string{"nonexistent_*"})
+		t.Assert(len(result), 0)
+	})
+}
+
+// Test filterTablesByPatterns - empty input.
+func Test_filterTablesByPatterns_Empty(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		allTables := []string{"trade_order", "trade_item"}
+
+		// Empty patterns
+		result := filterTablesByPatterns(allTables, []string{})
+		t.Assert(len(result), 0)
+
+		// Empty tables
+		result = filterTablesByPatterns([]string{}, []string{"trade_*"})
+		t.Assert(len(result), 0)
+	})
+}
+
+// Test filterTablesByPatterns - "*" matches all tables.
+func Test_filterTablesByPatterns_MatchAll(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		allTables := []string{"trade_order", "trade_item", "user_info", "user_log", "config"}
+
+		// "*" should match all tables
+		result := filterTablesByPatterns(allTables, []string{"*"})
+		t.Assert(len(result), 5)
+	})
+}
+
+// Test filterTablesByPatterns - non-existent exact table name should be skipped.
+func Test_filterTablesByPatterns_NonExistent(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		allTables := []string{"trade_order", "trade_item", "user_info"}
+
+		// Mix of existing and non-existing tables
+		result := filterTablesByPatterns(allTables, []string{"trade_order", "nonexistent", "user_info"})
+		t.Assert(len(result), 2)
+		t.AssertIN("trade_order", result)
+		t.AssertIN("user_info", result)
+		t.AssertNI("nonexistent", result)
+	})
+}

cmd/gf/internal/cmd/genenums/genenums.go

@@ -55,6 +55,13 @@ func (c CGenEnums) Enums(ctx context.Context, in CGenEnumsInput) (out *CGenEnums
 	if realPath == "" {
 		mlog.Fatalf(`source folder path "%s" does not exist`, in.Src)
 	}
+	// Convert output path to absolute before Chdir, so it remains correct after directory change.
+	// See: https://github.com/gogf/gf/issues/4387
+	outputPath := gfile.Abs(in.Path)
+
+	originPwd := gfile.Pwd()
+	defer gfile.Chdir(originPwd)
+
 	err = gfile.Chdir(realPath)
 	if err != nil {
 		mlog.Fatal(err)
@@ -72,14 +79,14 @@ func (c CGenEnums) Enums(ctx context.Context, in CGenEnumsInput) (out *CGenEnums
 	p := NewEnumsParser(in.Prefixes)
 	p.ParsePackages(pkgs)
 	var enumsContent = gstr.ReplaceByMap(consts.TemplateGenEnums, g.MapStrStr{
-		"{PackageName}": gfile.Basename(gfile.Dir(in.Path)),
+		"{PackageName}": gfile.Basename(gfile.Dir(outputPath)),
 		"{EnumsJson}":   "`" + p.Export() + "`",
 	})
 	enumsContent = gstr.Trim(enumsContent)
-	if err = gfile.PutContents(in.Path, enumsContent); err != nil {
+	if err = gfile.PutContents(outputPath, enumsContent); err != nil {
 		return
 	}
-	mlog.Printf(`generated enums go file: %s`, in.Path)
+	mlog.Printf(`generated enums go file: %s`, outputPath)
 	mlog.Print("done!")
 	return
 }

cmd/gf/internal/cmd/genenums/genenums_z_unit_test.go

@@ -0,0 +1,368 @@
+// Copyright GoFrame gf Author(https://goframe.org). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package genenums
+
+import (
+	"go/constant"
+	"path/filepath"
+	"testing"
+
+	"golang.org/x/tools/go/packages"
+
+	"github.com/gogf/gf/v2/encoding/gjson"
+	"github.com/gogf/gf/v2/os/gfile"
+	"github.com/gogf/gf/v2/test/gtest"
+	"github.com/gogf/gf/v2/util/guid"
+)
+
+func Test_NewEnumsParser(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test creating parser without prefixes
+		p := NewEnumsParser(nil)
+		t.AssertNE(p, nil)
+		t.Assert(len(p.enums), 0)
+		t.Assert(len(p.prefixes), 0)
+		t.AssertNE(p.parsedPkg, nil)
+		t.AssertNE(p.standardPackages, nil)
+	})
+}
+
+func Test_NewEnumsParser_WithPrefixes(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test creating parser with prefixes
+		prefixes := []string{"github.com/gogf", "github.com/test"}
+		p := NewEnumsParser(prefixes)
+		t.AssertNE(p, nil)
+		t.Assert(len(p.prefixes), 2)
+		t.Assert(p.prefixes[0], "github.com/gogf")
+		t.Assert(p.prefixes[1], "github.com/test")
+	})
+}
+
+func Test_EnumsParser_Export_Empty(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test exporting empty enums
+		p := NewEnumsParser(nil)
+		result := p.Export()
+		t.Assert(result, "{}")
+	})
+}
+
+func Test_EnumsParser_Export_WithEnums(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test exporting with manually added enums
+		p := NewEnumsParser(nil)
+
+		// Add some test enums
+		p.enums = []EnumItem{
+			{
+				Name:  "StatusActive",
+				Value: "1",
+				Type:  "pkg.Status",
+				Kind:  constant.Int,
+			},
+			{
+				Name:  "StatusInactive",
+				Value: "0",
+				Type:  "pkg.Status",
+				Kind:  constant.Int,
+			},
+			{
+				Name:  "TypeA",
+				Value: "type_a",
+				Type:  "pkg.Type",
+				Kind:  constant.String,
+			},
+		}
+
+		result := p.Export()
+		t.AssertNE(result, "")
+
+		// Parse the result to verify - use raw map to avoid gjson path issues with "."
+		var resultMap map[string][]interface{}
+		err := gjson.DecodeTo(result, &resultMap)
+		t.AssertNil(err)
+
+		// Verify Status type has 2 values
+		statusValues := resultMap["pkg.Status"]
+		t.Assert(len(statusValues), 2)
+
+		// Verify Type type has 1 value
+		typeValues := resultMap["pkg.Type"]
+		t.Assert(len(typeValues), 1)
+		t.Assert(typeValues[0], "type_a")
+	})
+}
+
+func Test_EnumsParser_Export_IntValues(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		p := NewEnumsParser(nil)
+		p.enums = []EnumItem{
+			{Name: "One", Value: "1", Type: "pkg.Int", Kind: constant.Int},
+			{Name: "Two", Value: "2", Type: "pkg.Int", Kind: constant.Int},
+			{Name: "Negative", Value: "-5", Type: "pkg.Int", Kind: constant.Int},
+		}
+
+		result := p.Export()
+		var resultMap map[string][]interface{}
+		err := gjson.DecodeTo(result, &resultMap)
+		t.AssertNil(err)
+
+		values := resultMap["pkg.Int"]
+		t.Assert(len(values), 3)
+		// Int values should be exported as integers (stored as float64 in JSON)
+		t.Assert(values[0], float64(1))
+		t.Assert(values[1], float64(2))
+		t.Assert(values[2], float64(-5))
+	})
+}
+
+func Test_EnumsParser_Export_FloatValues(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		p := NewEnumsParser(nil)
+		p.enums = []EnumItem{
+			{Name: "Pi", Value: "3.14159", Type: "pkg.Float", Kind: constant.Float},
+			{Name: "E", Value: "2.71828", Type: "pkg.Float", Kind: constant.Float},
+		}
+
+		result := p.Export()
+		var resultMap map[string][]interface{}
+		err := gjson.DecodeTo(result, &resultMap)
+		t.AssertNil(err)
+
+		values := resultMap["pkg.Float"]
+		t.Assert(len(values), 2)
+	})
+}
+
+func Test_EnumsParser_Export_BoolValues(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		p := NewEnumsParser(nil)
+		p.enums = []EnumItem{
+			{Name: "True", Value: "true", Type: "pkg.Bool", Kind: constant.Bool},
+			{Name: "False", Value: "false", Type: "pkg.Bool", Kind: constant.Bool},
+		}
+
+		result := p.Export()
+		var resultMap map[string][]interface{}
+		err := gjson.DecodeTo(result, &resultMap)
+		t.AssertNil(err)
+
+		values := resultMap["pkg.Bool"]
+		t.Assert(len(values), 2)
+		t.Assert(values[0], true)
+		t.Assert(values[1], false)
+	})
+}
+
+func Test_EnumsParser_Export_StringValues(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		p := NewEnumsParser(nil)
+		p.enums = []EnumItem{
+			{Name: "Hello", Value: "hello", Type: "pkg.Str", Kind: constant.String},
+			{Name: "World", Value: "world", Type: "pkg.Str", Kind: constant.String},
+		}
+
+		result := p.Export()
+		var resultMap map[string][]interface{}
+		err := gjson.DecodeTo(result, &resultMap)
+		t.AssertNil(err)
+
+		values := resultMap["pkg.Str"]
+		t.Assert(len(values), 2)
+		t.Assert(values[0], "hello")
+		t.Assert(values[1], "world")
+	})
+}
+
+func Test_EnumsParser_Export_MixedTypes(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		p := NewEnumsParser(nil)
+		p.enums = []EnumItem{
+			{Name: "IntVal", Value: "42", Type: "pkg.IntType", Kind: constant.Int},
+			{Name: "StrVal", Value: "test", Type: "pkg.StrType", Kind: constant.String},
+			{Name: "BoolVal", Value: "true", Type: "pkg.BoolType", Kind: constant.Bool},
+		}
+
+		result := p.Export()
+		var resultMap map[string][]interface{}
+		err := gjson.DecodeTo(result, &resultMap)
+		t.AssertNil(err)
+
+		// Each type should have its own array
+		t.Assert(len(resultMap["pkg.IntType"]), 1)
+		t.Assert(len(resultMap["pkg.StrType"]), 1)
+		t.Assert(len(resultMap["pkg.BoolType"]), 1)
+	})
+}
+
+func Test_EnumItem_Structure(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test EnumItem structure
+		item := EnumItem{
+			Name:  "TestEnum",
+			Value: "test_value",
+			Type:  "github.com/test/pkg.EnumType",
+			Kind:  constant.String,
+		}
+
+		t.Assert(item.Name, "TestEnum")
+		t.Assert(item.Value, "test_value")
+		t.Assert(item.Type, "github.com/test/pkg.EnumType")
+		t.Assert(item.Kind, constant.String)
+	})
+}
+
+func Test_EnumsParser_ParsePackages_Integration(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Create a temporary directory with a Go package containing enums
+		// Note: The module path must contain "/" for enums to be parsed
+		// (the parser skips std types without "/" in the type name)
+		tempDir := gfile.Temp(guid.S())
+		err := gfile.Mkdir(tempDir)
+		t.AssertNil(err)
+		defer gfile.Remove(tempDir)
+
+		// Create go.mod with a path containing "/"
+		goModContent := `module github.com/test/enumtest
+
+go 1.21
+`
+		err = gfile.PutContents(filepath.Join(tempDir, "go.mod"), goModContent)
+		t.AssertNil(err)
+
+		// Create a Go file with enum definitions
+		enumsContent := `package enumtest
+
+type Status int
+
+const (
+	StatusActive   Status = 1
+	StatusInactive Status = 0
+)
+
+type Color string
+
+const (
+	ColorRed   Color = "red"
+	ColorGreen Color = "green"
+	ColorBlue  Color = "blue"
+)
+`
+		err = gfile.PutContents(filepath.Join(tempDir, "enums.go"), enumsContent)
+		t.AssertNil(err)
+
+		// Load the package
+		cfg := &packages.Config{
+			Dir:   tempDir,
+			Mode:  pkgLoadMode,
+			Tests: false,
+		}
+		pkgs, err := packages.Load(cfg)
+		t.AssertNil(err)
+		t.Assert(len(pkgs) > 0, true)
+
+		// Parse the packages
+		p := NewEnumsParser(nil)
+		p.ParsePackages(pkgs)
+
+		// Export and verify - result should contain parsed enums
+		result := p.Export()
+		// Verify the export contains some data
+		t.Assert(len(result) > 2, true) // More than just "{}"
+
+		// Parse result as raw map to handle keys with "/"
+		var resultMap map[string][]interface{}
+		err = gjson.DecodeTo(result, &resultMap)
+		t.AssertNil(err)
+
+		// Verify Status enum was parsed (type will be "github.com/test/enumtest.Status")
+		statusKey := "github.com/test/enumtest.Status"
+		statusValues, hasStatus := resultMap[statusKey]
+		t.Assert(hasStatus, true)
+		t.Assert(len(statusValues), 2)
+
+		// Verify Color enum was parsed
+		colorKey := "github.com/test/enumtest.Color"
+		colorValues, hasColor := resultMap[colorKey]
+		t.Assert(hasColor, true)
+		t.Assert(len(colorValues), 3)
+	})
+}
+
+func Test_EnumsParser_ParsePackages_WithPrefixes(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Create a temporary directory with a Go package
+		tempDir := gfile.Temp(guid.S())
+		err := gfile.Mkdir(tempDir)
+		t.AssertNil(err)
+		defer gfile.Remove(tempDir)
+
+		// Create go.mod with a specific module name
+		goModContent := `module github.com/allowed/pkg
+
+go 1.21
+`
+		err = gfile.PutContents(filepath.Join(tempDir, "go.mod"), goModContent)
+		t.AssertNil(err)
+
+		// Create a Go file with enum definitions
+		enumsContent := `package pkg
+
+type Status int
+
+const (
+	StatusOK Status = 1
+)
+`
+		err = gfile.PutContents(filepath.Join(tempDir, "enums.go"), enumsContent)
+		t.AssertNil(err)
+
+		// Load the package
+		cfg := &packages.Config{
+			Dir:   tempDir,
+			Mode:  pkgLoadMode,
+			Tests: false,
+		}
+		pkgs, err := packages.Load(cfg)
+		t.AssertNil(err)
+
+		// Parse with prefix filter that matches
+		p := NewEnumsParser([]string{"github.com/allowed"})
+		p.ParsePackages(pkgs)
+
+		result := p.Export()
+		// Should have enums because prefix matches
+		t.AssertNE(result, "{}")
+
+		// Parse with prefix filter that doesn't match
+		p2 := NewEnumsParser([]string{"github.com/other"})
+		p2.ParsePackages(pkgs)
+
+		result2 := p2.Export()
+		// Should be empty because prefix doesn't match
+		t.Assert(result2, "{}")
+	})
+}
+
+func Test_getStandardPackages(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		stdPkgs := getStandardPackages()
+		t.AssertNE(stdPkgs, nil)
+		t.Assert(len(stdPkgs) > 0, true)
+
+		// Verify some common standard packages are included
+		_, hasFmt := stdPkgs["fmt"]
+		t.Assert(hasFmt, true)
+
+		_, hasOs := stdPkgs["os"]
+		t.Assert(hasOs, true)
+
+		_, hasContext := stdPkgs["context"]
+		t.Assert(hasContext, true)
+	})
+}

cmd/gf/internal/cmd/geninit/geninit.go

@@ -86,7 +86,7 @@ func processGoModule(ctx context.Context, repo, name string, opts *ProcessOption
 	// 1. Determine version to use
 	var targetVersion string
 	if specifiedVersion != "" {
-		// User specified version
+		// User specified version, try to use it first
 		targetVersion = specifiedVersion
 		mlog.Printf("Using specified version: %s", targetVersion)
 	} else if opts.SelectVersion {
@@ -120,8 +120,41 @@ func processGoModule(ctx context.Context, repo, name string, opts *ProcessOption
 	repoWithVersion := modulePath + "@" + targetVersion
 	srcDir, err := downloadTemplate(ctx, repoWithVersion)
 	if err != nil {
-		mlog.Printf("Download failed: %v", err)
-		return err
+		// If specified version download failed, offer to select from available versions
+		if specifiedVersion != "" {
+			mlog.Printf("Failed to download specified version '%s': %v", specifiedVersion, err)
+			mlog.Print("Fetching available versions...")
+
+			versionInfo, verErr := GetModuleVersions(ctx, modulePath)
+			if verErr != nil {
+				mlog.Printf("Failed to get available versions: %v", verErr)
+				return err // Return original download error
+			}
+
+			if len(versionInfo.Versions) == 0 {
+				mlog.Print("No versions available for this module")
+				return err
+			}
+
+			// Let user select from available versions
+			selectedVersion, selErr := SelectVersion(ctx, versionInfo.Versions, modulePath)
+			if selErr != nil {
+				mlog.Printf("Version selection failed: %v", selErr)
+				return selErr
+			}
+
+			// Retry download with selected version
+			targetVersion = selectedVersion
+			repoWithVersion = modulePath + "@" + targetVersion
+			srcDir, err = downloadTemplate(ctx, repoWithVersion)
+			if err != nil {
+				mlog.Printf("Download failed: %v", err)
+				return err
+			}
+		} else {
+			mlog.Printf("Download failed: %v", err)
+			return err
+		}
 	}
 
 	mlog.Debugf("Template located at: %s", srcDir)

cmd/gf/internal/cmd/geninit/geninit_ast.go

@@ -78,11 +78,10 @@ func (r *ASTReplacer) ReplaceInFile(ctx context.Context, filePath string) error
 		return nil
 	}
 
-	// Write back to file
+	// Write back to file without formatting.
+	// Formatting will be handled by formatGoFiles after all replacements are done.
 	var buf bytes.Buffer
-	// Use default printer configuration to match gofmt output
-	cfg := &printer.Config{}
-	if err := cfg.Fprint(&buf, r.fset, file); err != nil {
+	if err := printer.Fprint(&buf, r.fset, file); err != nil {
 		return err
 	}
 

cmd/gf/internal/cmd/geninit/geninit_generator.go

@@ -9,6 +9,7 @@ package geninit
 import (
 	"context"
 	"fmt"
+	"go/format"
 	"path/filepath"
 
 	"github.com/gogf/gf/v2/os/gfile"
@@ -81,6 +82,11 @@ func generateProject(ctx context.Context, srcPath, name, oldModule, newModule st
 		}
 	}
 
+	// 6. Format the generated Go files using go/format (not imports.Process)
+	// Note: We use formatGoFiles instead of utils.GoFmt because imports.Process
+	// may incorrectly "fix" local import paths by replacing them with cached module paths.
+	formatGoFiles(dstPath)
+
 	mlog.Print("Project generated successfully!")
 	return nil
 }
@@ -108,3 +114,33 @@ func upgradeDependencies(ctx context.Context, projectDir string) error {
 	mlog.Print("Dependencies upgraded successfully!")
 	return nil
 }
+
+// formatGoFiles formats all Go files in the directory using go/format.
+// Unlike imports.Process, this only formats code without modifying imports,
+// which prevents incorrect "fixing" of local import paths.
+func formatGoFiles(dir string) {
+	files, err := findGoFiles(dir)
+	if err != nil {
+		mlog.Printf("Failed to find Go files for formatting: %v", err)
+		return
+	}
+
+	for _, file := range files {
+		content := gfile.GetContents(file)
+		if content == "" {
+			continue
+		}
+
+		formatted, err := format.Source([]byte(content))
+		if err != nil {
+			mlog.Debugf("Failed to format %s: %v", file, err)
+			continue
+		}
+
+		if string(formatted) != content {
+			if err := gfile.PutContents(file, string(formatted)); err != nil {
+				mlog.Debugf("Failed to write formatted file %s: %v", file, err)
+			}
+		}
+	}
+}

cmd/gf/internal/cmd/geninit/geninit_z_unit_test.go

@@ -0,0 +1,359 @@
+// Copyright GoFrame gf Author(https://goframe.org). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package geninit
+
+import (
+	"context"
+	"path/filepath"
+	"testing"
+
+	"github.com/gogf/gf/v2/os/gfile"
+	"github.com/gogf/gf/v2/test/gtest"
+	"github.com/gogf/gf/v2/util/guid"
+)
+
+func Test_ParseGitURL_Basic(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test basic github URL
+		info, err := ParseGitURL("github.com/gogf/gf")
+		t.AssertNil(err)
+		t.Assert(info.Host, "github.com")
+		t.Assert(info.Owner, "gogf")
+		t.Assert(info.Repo, "gf")
+		t.Assert(info.SubPath, "")
+		t.Assert(info.Branch, "main")
+		t.Assert(info.CloneURL, "https://github.com/gogf/gf.git")
+	})
+}
+
+func Test_ParseGitURL_WithHTTPS(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test URL with https prefix
+		info, err := ParseGitURL("https://github.com/gogf/gf")
+		t.AssertNil(err)
+		t.Assert(info.Host, "github.com")
+		t.Assert(info.Owner, "gogf")
+		t.Assert(info.Repo, "gf")
+	})
+}
+
+func Test_ParseGitURL_WithGitSuffix(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test URL with .git suffix
+		info, err := ParseGitURL("github.com/gogf/gf.git")
+		t.AssertNil(err)
+		t.Assert(info.Host, "github.com")
+		t.Assert(info.Owner, "gogf")
+		t.Assert(info.Repo, "gf")
+	})
+}
+
+func Test_ParseGitURL_WithSubPath(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test URL with subdirectory
+		info, err := ParseGitURL("github.com/gogf/examples/httpserver/jwt")
+		t.AssertNil(err)
+		t.Assert(info.Host, "github.com")
+		t.Assert(info.Owner, "gogf")
+		t.Assert(info.Repo, "examples")
+		t.Assert(info.SubPath, "httpserver/jwt")
+		t.Assert(info.CloneURL, "https://github.com/gogf/examples.git")
+	})
+}
+
+func Test_ParseGitURL_WithTreeBranch(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test GitHub web URL with /tree/branch/
+		info, err := ParseGitURL("github.com/gogf/examples/tree/develop/httpserver/jwt")
+		t.AssertNil(err)
+		t.Assert(info.Host, "github.com")
+		t.Assert(info.Owner, "gogf")
+		t.Assert(info.Repo, "examples")
+		t.Assert(info.Branch, "develop")
+		t.Assert(info.SubPath, "httpserver/jwt")
+	})
+}
+
+func Test_ParseGitURL_WithVersion(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test URL with version suffix
+		info, err := ParseGitURL("github.com/gogf/gf/cmd/gf/v2@v2.9.7")
+		t.AssertNil(err)
+		t.Assert(info.Host, "github.com")
+		t.Assert(info.Owner, "gogf")
+		t.Assert(info.Repo, "gf")
+		t.Assert(info.SubPath, "cmd/gf/v2")
+	})
+}
+
+func Test_ParseGitURL_Invalid(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test invalid URL (too short)
+		_, err := ParseGitURL("github.com/gogf")
+		t.AssertNE(err, nil)
+	})
+}
+
+func Test_IsSubdirRepo_NotSubdir(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Standard Go module paths should not be detected as subdirectory
+		t.Assert(IsSubdirRepo("github.com/gogf/gf"), false)
+		t.Assert(IsSubdirRepo("github.com/gogf/gf/v2"), false)
+	})
+}
+
+func Test_IsSubdirRepo_GoModuleWithCmd(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Go module paths with common patterns should not be detected as subdirectory
+		t.Assert(IsSubdirRepo("github.com/gogf/gf/cmd/gf/v2"), false)
+		t.Assert(IsSubdirRepo("github.com/gogf/gf/contrib/drivers/mysql/v2"), false)
+	})
+}
+
+func Test_IsSubdirRepo_ActualSubdir(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Actual subdirectories should be detected
+		t.Assert(IsSubdirRepo("github.com/gogf/examples/httpserver/jwt"), true)
+		t.Assert(IsSubdirRepo("github.com/gogf/examples/grpc/basic"), true)
+	})
+}
+
+func Test_GetModuleNameFromGoMod_Valid(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Create temp directory with go.mod
+		tempDir := gfile.Temp(guid.S())
+		err := gfile.Mkdir(tempDir)
+		t.AssertNil(err)
+		defer gfile.Remove(tempDir)
+
+		// Write go.mod file
+		goModContent := `module github.com/test/myproject
+
+go 1.21
+
+require (
+	github.com/gogf/gf/v2 v2.9.0
+)
+`
+		err = gfile.PutContents(filepath.Join(tempDir, "go.mod"), goModContent)
+		t.AssertNil(err)
+
+		// Test extraction
+		moduleName := GetModuleNameFromGoMod(tempDir)
+		t.Assert(moduleName, "github.com/test/myproject")
+	})
+}
+
+func Test_GetModuleNameFromGoMod_NoFile(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Create temp directory without go.mod
+		tempDir := gfile.Temp(guid.S())
+		err := gfile.Mkdir(tempDir)
+		t.AssertNil(err)
+		defer gfile.Remove(tempDir)
+
+		// Test extraction - should return empty
+		moduleName := GetModuleNameFromGoMod(tempDir)
+		t.Assert(moduleName, "")
+	})
+}
+
+func Test_GetModuleNameFromGoMod_SimpleModule(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Create temp directory with simple go.mod
+		tempDir := gfile.Temp(guid.S())
+		err := gfile.Mkdir(tempDir)
+		t.AssertNil(err)
+		defer gfile.Remove(tempDir)
+
+		// Write simple go.mod file
+		goModContent := `module main
+
+go 1.21
+`
+		err = gfile.PutContents(filepath.Join(tempDir, "go.mod"), goModContent)
+		t.AssertNil(err)
+
+		// Test extraction
+		moduleName := GetModuleNameFromGoMod(tempDir)
+		t.Assert(moduleName, "main")
+	})
+}
+
+func Test_ASTReplacer_ReplaceInFile(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Create temp directory
+		tempDir := gfile.Temp(guid.S())
+		err := gfile.Mkdir(tempDir)
+		t.AssertNil(err)
+		defer gfile.Remove(tempDir)
+
+		// Create a Go file with imports
+		goFileContent := `package main
+
+import (
+	"fmt"
+
+	"github.com/old/module/internal/service"
+	"github.com/old/module/pkg/utils"
+	"github.com/other/package"
+)
+
+func main() {
+	fmt.Println("Hello")
+}
+`
+		goFilePath := filepath.Join(tempDir, "main.go")
+		err = gfile.PutContents(goFilePath, goFileContent)
+		t.AssertNil(err)
+
+		// Replace imports
+		replacer := NewASTReplacer("github.com/old/module", "github.com/new/project")
+		err = replacer.ReplaceInFile(context.Background(), goFilePath)
+		t.AssertNil(err)
+
+		// Verify replacement
+		content := gfile.GetContents(goFilePath)
+		t.Assert(gfile.Exists(goFilePath), true)
+
+		// Check that old imports are replaced
+		t.AssertNE(content, "")
+		t.Assert(contains(content, `"github.com/new/project/internal/service"`), true)
+		t.Assert(contains(content, `"github.com/new/project/pkg/utils"`), true)
+
+		// Check that other imports are not affected
+		t.Assert(contains(content, `"github.com/other/package"`), true)
+		t.Assert(contains(content, `"fmt"`), true)
+	})
+}
+
+func Test_ASTReplacer_ReplaceInDir(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Create temp directory structure
+		tempDir := gfile.Temp(guid.S())
+		err := gfile.Mkdir(tempDir)
+		t.AssertNil(err)
+		defer gfile.Remove(tempDir)
+
+		// Create subdirectory
+		subDir := filepath.Join(tempDir, "sub")
+		err = gfile.Mkdir(subDir)
+		t.AssertNil(err)
+
+		// Create main.go
+		mainContent := `package main
+
+import "github.com/old/module/sub"
+
+func main() {
+	sub.Hello()
+}
+`
+		err = gfile.PutContents(filepath.Join(tempDir, "main.go"), mainContent)
+		t.AssertNil(err)
+
+		// Create sub/sub.go
+		subContent := `package sub
+
+import "github.com/old/module/pkg"
+
+func Hello() {
+	pkg.Do()
+}
+`
+		err = gfile.PutContents(filepath.Join(subDir, "sub.go"), subContent)
+		t.AssertNil(err)
+
+		// Replace imports in directory
+		replacer := NewASTReplacer("github.com/old/module", "github.com/new/project")
+		err = replacer.ReplaceInDir(context.Background(), tempDir)
+		t.AssertNil(err)
+
+		// Verify main.go replacement
+		mainResult := gfile.GetContents(filepath.Join(tempDir, "main.go"))
+		t.Assert(contains(mainResult, `"github.com/new/project/sub"`), true)
+
+		// Verify sub/sub.go replacement
+		subResult := gfile.GetContents(filepath.Join(subDir, "sub.go"))
+		t.Assert(contains(subResult, `"github.com/new/project/pkg"`), true)
+	})
+}
+
+func Test_findGoFiles(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Create temp directory structure
+		tempDir := gfile.Temp(guid.S())
+		err := gfile.Mkdir(tempDir)
+		t.AssertNil(err)
+		defer gfile.Remove(tempDir)
+
+		// Create subdirectories
+		subDir := filepath.Join(tempDir, "sub")
+		err = gfile.Mkdir(subDir)
+		t.AssertNil(err)
+
+		// Create various files
+		err = gfile.PutContents(filepath.Join(tempDir, "main.go"), "package main")
+		t.AssertNil(err)
+		err = gfile.PutContents(filepath.Join(tempDir, "readme.md"), "# README")
+		t.AssertNil(err)
+		err = gfile.PutContents(filepath.Join(subDir, "sub.go"), "package sub")
+		t.AssertNil(err)
+		err = gfile.PutContents(filepath.Join(subDir, "data.json"), "{}")
+		t.AssertNil(err)
+
+		// Find Go files
+		files, err := findGoFiles(tempDir)
+		t.AssertNil(err)
+
+		// Should find exactly 2 Go files
+		t.Assert(len(files), 2)
+
+		// Verify file names
+		hasMain := false
+		hasSub := false
+		for _, f := range files {
+			if filepath.Base(f) == "main.go" {
+				hasMain = true
+			}
+			if filepath.Base(f) == "sub.go" {
+				hasSub = true
+			}
+		}
+		t.Assert(hasMain, true)
+		t.Assert(hasSub, true)
+	})
+}
+
+func Test_findGoFiles_EmptyDir(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Create empty temp directory
+		tempDir := gfile.Temp(guid.S())
+		err := gfile.Mkdir(tempDir)
+		t.AssertNil(err)
+		defer gfile.Remove(tempDir)
+
+		// Find Go files
+		files, err := findGoFiles(tempDir)
+		t.AssertNil(err)
+		t.Assert(len(files), 0)
+	})
+}
+
+// Helper function to check if string contains substring
+func contains(s, substr string) bool {
+	return len(s) >= len(substr) && (s == substr || len(s) > 0 && containsAt(s, substr))
+}
+
+func containsAt(s, substr string) bool {
+	for i := 0; i <= len(s)-len(substr); i++ {
+		if s[i:i+len(substr)] == substr {
+			return true
+		}
+	}
+	return false
+}

cmd/gf/internal/cmd/genservice/genservice_calculate.go

@@ -12,7 +12,6 @@ import (
 
 	"github.com/gogf/gf/v2/container/garray"
 	"github.com/gogf/gf/v2/container/gmap"
-	"github.com/gogf/gf/v2/os/gfile"
 	"github.com/gogf/gf/v2/text/gregex"
 	"github.com/gogf/gf/v2/text/gstr"
 
@@ -37,21 +36,14 @@ func (c CGenService) calculateImportedItems(
 	}
 
 	for _, item := range pkgItems {
-		alias := item.Alias
-
-		// If the alias is _, it means that the package is not generated.
-		if alias == "_" {
+		// Skip anonymous imports
+		if item.Alias == "_" {
 			mlog.Debugf(`ignore anonymous package: %s`, item.RawImport)
 			continue
 		}
-		// If the alias is empty, it will use the package name as the alias.
-		if alias == "" {
-			alias = gfile.Basename(gstr.Trim(item.Path, `"`))
-		}
-		if !gstr.Contains(allFuncParamType.String(), alias) {
-			mlog.Debugf(`ignore unused package: %s`, item.RawImport)
-			continue
-		}
+		// Keep all imports, let gofmt clean up unused ones.
+		// We cannot accurately infer package name from import path
+		// (e.g., path "minio-go" but package name is "minio").
 		srcImportedPackages.Add(item.RawImport)
 	}
 	return nil

cmd/gf/internal/cmd/testdata/build/varmap/go.mod

@@ -4,7 +4,7 @@ go 1.23.0
 
 toolchain go1.24.6
 
-require github.com/gogf/gf/v2 v2.9.6
+require github.com/gogf/gf/v2 v2.10.0
 
 require (
 	go.opentelemetry.io/otel v1.38.0 // indirect

cmd/gf/internal/cmd/testdata/genctrl/default/api/article/article_expect.go

@@ -7,8 +7,8 @@ package article
 import (
 	"context"
 
-	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/api/article/v1"
-	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/api/article/v2"
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/default/api/article/v1"
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/default/api/article/v2"
 )
 
 type IArticleV1 interface {

cmd/gf/internal/cmd/testdata/genctrl/default/controller/article/article_new.go

@@ -5,7 +5,7 @@
 package article
 
 import (
-	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/api/article"
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/default/api/article"
 )
 
 type ControllerV1 struct{}

cmd/gf/internal/cmd/testdata/genctrl/default/controller/article/article_v1_create.go

@@ -6,7 +6,7 @@ import (
 	"github.com/gogf/gf/v2/errors/gcode"
 	"github.com/gogf/gf/v2/errors/gerror"
 
-	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/api/article/v1"
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/default/api/article/v1"
 )
 
 // Create add title.

cmd/gf/internal/cmd/testdata/genctrl/default/controller/article/article_v1_get_list.go

@@ -6,7 +6,7 @@ import (
 	"github.com/gogf/gf/v2/errors/gcode"
 	"github.com/gogf/gf/v2/errors/gerror"
 
-	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/api/article/v1"
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/default/api/article/v1"
 )
 
 func (c *ControllerV1) GetList(ctx context.Context, req *v1.GetListReq) (res *v1.GetListRes, err error) {

cmd/gf/internal/cmd/testdata/genctrl/default/controller/article/article_v1_get_one.go

@@ -6,7 +6,7 @@ import (
 	"github.com/gogf/gf/v2/errors/gcode"
 	"github.com/gogf/gf/v2/errors/gerror"
 
-	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/api/article/v1"
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/default/api/article/v1"
 )
 
 func (c *ControllerV1) GetOne(ctx context.Context, req *v1.GetOneReq) (res *v1.GetOneRes, err error) {

cmd/gf/internal/cmd/testdata/genctrl/default/controller/article/article_v1_update.go

@@ -6,7 +6,7 @@ import (
 	"github.com/gogf/gf/v2/errors/gcode"
 	"github.com/gogf/gf/v2/errors/gerror"
 
-	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/api/article/v1"
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/default/api/article/v1"
 )
 
 func (c *ControllerV1) Update(ctx context.Context, req *v1.UpdateReq) (res *v1.UpdateRes, err error) {

cmd/gf/internal/cmd/testdata/genctrl/default/controller/article/article_v2_create.go

@@ -6,7 +6,7 @@ import (
 	"github.com/gogf/gf/v2/errors/gcode"
 	"github.com/gogf/gf/v2/errors/gerror"
 
-	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/api/article/v2"
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/default/api/article/v2"
 )
 
 func (c *ControllerV2) Create(ctx context.Context, req *v2.CreateReq) (res *v2.CreateRes, err error) {

cmd/gf/internal/cmd/testdata/genctrl/default/controller/article/article_v2_update.go

@@ -6,7 +6,7 @@ import (
 	"github.com/gogf/gf/v2/errors/gcode"
 	"github.com/gogf/gf/v2/errors/gerror"
 
-	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/api/article/v2"
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/default/api/article/v2"
 )
 
 func (c *ControllerV2) Update(ctx context.Context, req *v2.UpdateReq) (res *v2.UpdateRes, err error) {

cmd/gf/internal/cmd/testdata/genctrl/merge/add_new_ctrl/api/dict/dict_add_new_ctrl_expect.gotest

@@ -7,7 +7,7 @@ package dict
 import (
 	"context"
 
-	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl-merge/add_new_ctrl/api/dict/v1"
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/merge/add_new_ctrl/api/dict/v1"
 )
 
 type IDictV1 interface {

cmd/gf/internal/cmd/testdata/genctrl/merge/add_new_ctrl/api/dict/dict_expect.go

@@ -7,7 +7,7 @@ package dict
 import (
 	"context"
 
-	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl-merge/add_new_ctrl/api/dict/v1"
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/merge/add_new_ctrl/api/dict/v1"
 )
 
 type IDictV1 interface {

cmd/gf/internal/cmd/testdata/genctrl/merge/add_new_ctrl/controller/dict/dict_new.go

@@ -5,7 +5,7 @@
 package dict
 
 import (
-	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl-merge/add_new_ctrl/api/dict"
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/merge/add_new_ctrl/api/dict"
 )
 
 type ControllerV1 struct{}

cmd/gf/internal/cmd/testdata/genctrl/merge/add_new_ctrl/controller/dict/dict_v1_dict_type.go

@@ -6,7 +6,7 @@ import (
 	"github.com/gogf/gf/v2/errors/gcode"
 	"github.com/gogf/gf/v2/errors/gerror"
 
-	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl-merge/add_new_ctrl/api/dict/v1"
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/merge/add_new_ctrl/api/dict/v1"
 )
 
 func (c *ControllerV1) DictTypeAddPage(ctx context.Context, req *v1.DictTypeAddPageReq) (res *v1.DictTypeAddPageRes, err error) {

cmd/gf/internal/cmd/testdata/genctrl/merge/add_new_ctrl/controller/dict/dict_v1_test_new.gotest

@@ -6,7 +6,7 @@ import (
 	"github.com/gogf/gf/v2/errors/gcode"
 	"github.com/gogf/gf/v2/errors/gerror"
 
-	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl-merge/add_new_ctrl/api/dict/v1"
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/merge/add_new_ctrl/api/dict/v1"
 )
 
 func (c *ControllerV1) DictTypeAddPage(ctx context.Context, req *v1.DictTypeAddPageReq) (res *v1.DictTypeAddPageRes, err error) {

cmd/gf/internal/cmd/testdata/genctrl/merge/add_new_file/api/dict/dict_add_new_ctrl_expect.gotest

@@ -7,7 +7,7 @@ package dict
 import (
 	"context"
 
-	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl-merge/add_new_ctrl/api/dict/v1"
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/merge/add_new_ctrl/api/dict/v1"
 )
 
 type IDictV1 interface {

cmd/gf/internal/cmd/testdata/genctrl/merge/add_new_file/api/dict/dict_expect.go

@@ -7,7 +7,7 @@ package dict
 import (
 	"context"
 
-	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl-merge/add_new_file/api/dict/v1"
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/merge/add_new_file/api/dict/v1"
 )
 
 type IDictV1 interface {

cmd/gf/internal/cmd/testdata/genctrl/merge/add_new_file/controller/dict/dict_new.go

@@ -5,7 +5,7 @@
 package dict
 
 import (
-	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl-merge/add_new_file/api/dict"
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/merge/add_new_file/api/dict"
 )
 
 type ControllerV1 struct{}

cmd/gf/internal/cmd/testdata/genctrl/merge/add_new_file/controller/dict/dict_v1_dict_type.go

@@ -6,7 +6,7 @@ import (
 	"github.com/gogf/gf/v2/errors/gcode"
 	"github.com/gogf/gf/v2/errors/gerror"
 
-	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl-merge/add_new_file/api/dict/v1"
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/merge/add_new_file/api/dict/v1"
 )
 
 func (c *ControllerV1) DictTypeAddPage(ctx context.Context, req *v1.DictTypeAddPageReq) (res *v1.DictTypeAddPageRes, err error) {

cmd/gf/internal/cmd/testdata/genctrl/merge/add_new_file/controller/dict/dict_v1_test_new.gotest

@@ -6,7 +6,7 @@ import (
 	"github.com/gogf/gf/v2/errors/gcode"
 	"github.com/gogf/gf/v2/errors/gerror"
 
-	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl-merge/add_new_file/api/dict/v1"
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/merge/add_new_file/api/dict/v1"
 )
 
 func (c *ControllerV1) DictTypeAdd(ctx context.Context, req *v1.DictTypeAddReq) (res *v1.DictTypeAddRes, err error) {

cmd/gf/internal/cmd/testdata/genctrl/multi/api/admin/article/article_expect.go

@@ -0,0 +1,15 @@
+// =================================================================================
+// Code generated and maintained by GoFrame CLI tool. DO NOT EDIT.
+// =================================================================================
+
+package article
+
+import (
+	"context"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/multi/api/admin/article/v1"
+)
+
+type IArticleV1 interface {
+	Create(ctx context.Context, req *v1.CreateReq) (res *v1.CreateRes, err error)
+}

cmd/gf/internal/cmd/testdata/genctrl/multi/api/admin/article/v1/edit.go

@@ -0,0 +1,19 @@
+// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package v1
+
+import "github.com/gogf/gf/v2/frame/g"
+
+type (
+	// CreateReq add title.
+	CreateReq struct {
+		g.Meta `path:"/article/create" method:"post" tags:"ArticleService"`
+		Title  string `v:"required"`
+	}
+
+	CreateRes struct{}
+)

cmd/gf/internal/cmd/testdata/genctrl/multi/api/admin/user/user_expect.go

@@ -0,0 +1,15 @@
+// =================================================================================
+// Code generated and maintained by GoFrame CLI tool. DO NOT EDIT.
+// =================================================================================
+
+package user
+
+import (
+	"context"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/multi/api/admin/user/v1"
+)
+
+type IUserV1 interface {
+	Create(ctx context.Context, req *v1.CreateReq) (res *v1.CreateRes, err error)
+}

cmd/gf/internal/cmd/testdata/genctrl/multi/api/admin/user/v1/edit.go

@@ -0,0 +1,19 @@
+// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package v1
+
+import "github.com/gogf/gf/v2/frame/g"
+
+type (
+	// CreateReq add title.
+	CreateReq struct {
+		g.Meta `path:"/article/create" method:"post" tags:"ArticleService"`
+		Title  string `v:"required"`
+	}
+
+	CreateRes struct{}
+)

cmd/gf/internal/cmd/testdata/genctrl/multi/api/app/user/user_expect.go

@@ -0,0 +1,16 @@
+// =================================================================================
+// Code generated and maintained by GoFrame CLI tool. DO NOT EDIT.
+// =================================================================================
+
+package user
+
+import (
+	"context"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/multi/api/app/user/v1"
+)
+
+type IUserV1 interface {
+	Create(ctx context.Context, req *v1.CreateReq) (res *v1.CreateRes, err error)
+	Update(ctx context.Context, req *v1.UpdateReq) (res *v1.UpdateRes, err error)
+}

cmd/gf/internal/cmd/testdata/genctrl/multi/api/app/user/user_ext/user_ext_expect.go

@@ -0,0 +1,16 @@
+// =================================================================================
+// Code generated and maintained by GoFrame CLI tool. DO NOT EDIT.
+// =================================================================================
+
+package user_ext
+
+import (
+	"context"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/multi/api/app/user/user_ext/v1"
+)
+
+type IUserExtV1 interface {
+	Create(ctx context.Context, req *v1.CreateReq) (res *v1.CreateRes, err error)
+	Update(ctx context.Context, req *v1.UpdateReq) (res *v1.UpdateRes, err error)
+}

cmd/gf/internal/cmd/testdata/genctrl/multi/api/app/user/user_ext/v1/edit.go

@@ -0,0 +1,28 @@
+// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package v1
+
+import "github.com/gogf/gf/v2/frame/g"
+
+type (
+	// CreateReq add title.
+	CreateReq struct {
+		g.Meta `path:"/article/create" method:"post" tags:"ArticleService"`
+		Title  string `v:"required"`
+	}
+
+	CreateRes struct{}
+)
+
+type (
+	UpdateReq struct {
+		g.Meta `path:"/article/update" method:"post" tags:"ArticleService"`
+		Title  string `v:"required"`
+	}
+
+	UpdateRes struct{}
+)

cmd/gf/internal/cmd/testdata/genctrl/multi/api/app/user/v1/edit.go

@@ -0,0 +1,28 @@
+// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package v1
+
+import "github.com/gogf/gf/v2/frame/g"
+
+type (
+	// CreateReq add title.
+	CreateReq struct {
+		g.Meta `path:"/article/create" method:"post" tags:"ArticleService"`
+		Title  string `v:"required"`
+	}
+
+	CreateRes struct{}
+)
+
+type (
+	UpdateReq struct {
+		g.Meta `path:"/article/update" method:"post" tags:"ArticleService"`
+		Title  string `v:"required"`
+	}
+
+	UpdateRes struct{}
+)

cmd/gf/internal/cmd/testdata/genctrl/multi/controller/admin/article/article.go

@@ -0,0 +1,5 @@
+// =================================================================================
+// This is auto-generated by GoFrame CLI tool only once. Fill this file as you wish.
+// =================================================================================
+
+package article

cmd/gf/internal/cmd/testdata/genctrl/multi/controller/admin/article/article_new.go

@@ -0,0 +1,15 @@
+// =================================================================================
+// This is auto-generated by GoFrame CLI tool only once. Fill this file as you wish.
+// =================================================================================
+
+package article
+
+import (
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/multi/api/admin/article"
+)
+
+type ControllerV1 struct{}
+
+func NewV1() article.IArticleV1 {
+	return &ControllerV1{}
+}

cmd/gf/internal/cmd/testdata/genctrl/multi/controller/admin/article/article_v1_create.go

@@ -0,0 +1,15 @@
+package article
+
+import (
+	"context"
+
+	"github.com/gogf/gf/v2/errors/gcode"
+	"github.com/gogf/gf/v2/errors/gerror"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/multi/api/admin/article/v1"
+)
+
+// Create add title.
+func (c *ControllerV1) Create(ctx context.Context, req *v1.CreateReq) (res *v1.CreateRes, err error) {
+	return nil, gerror.NewCode(gcode.CodeNotImplemented)
+}

cmd/gf/internal/cmd/testdata/genctrl/multi/controller/admin/user/user.go

@@ -0,0 +1,5 @@
+// =================================================================================
+// This is auto-generated by GoFrame CLI tool only once. Fill this file as you wish.
+// =================================================================================
+
+package user

cmd/gf/internal/cmd/testdata/genctrl/multi/controller/admin/user/user_new.go

@@ -0,0 +1,15 @@
+// =================================================================================
+// This is auto-generated by GoFrame CLI tool only once. Fill this file as you wish.
+// =================================================================================
+
+package user
+
+import (
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/multi/api/admin/user"
+)
+
+type ControllerV1 struct{}
+
+func NewV1() user.IUserV1 {
+	return &ControllerV1{}
+}

cmd/gf/internal/cmd/testdata/genctrl/multi/controller/admin/user/user_v1_create.go

@@ -0,0 +1,15 @@
+package user
+
+import (
+	"context"
+
+	"github.com/gogf/gf/v2/errors/gcode"
+	"github.com/gogf/gf/v2/errors/gerror"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/multi/api/admin/user/v1"
+)
+
+// Create add title.
+func (c *ControllerV1) Create(ctx context.Context, req *v1.CreateReq) (res *v1.CreateRes, err error) {
+	return nil, gerror.NewCode(gcode.CodeNotImplemented)
+}

cmd/gf/internal/cmd/testdata/genctrl/multi/controller/app/user/user.go

@@ -0,0 +1,5 @@
+// =================================================================================
+// This is auto-generated by GoFrame CLI tool only once. Fill this file as you wish.
+// =================================================================================
+
+package user

cmd/gf/internal/cmd/testdata/genctrl/multi/controller/app/user/user_ext/user_ext.go

@@ -0,0 +1,5 @@
+// =================================================================================
+// This is auto-generated by GoFrame CLI tool only once. Fill this file as you wish.
+// =================================================================================
+
+package user_ext

cmd/gf/internal/cmd/testdata/genctrl/multi/controller/app/user/user_ext/user_ext_new.go

@@ -0,0 +1,15 @@
+// =================================================================================
+// This is auto-generated by GoFrame CLI tool only once. Fill this file as you wish.
+// =================================================================================
+
+package user_ext
+
+import (
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/multi/api/app/user/user_ext"
+)
+
+type ControllerV1 struct{}
+
+func NewV1() user_ext.IUserExtV1 {
+	return &ControllerV1{}
+}

cmd/gf/internal/cmd/testdata/genctrl/multi/controller/app/user/user_ext/user_ext_v1_create.go

@@ -0,0 +1,15 @@
+package user_ext
+
+import (
+	"context"
+
+	"github.com/gogf/gf/v2/errors/gcode"
+	"github.com/gogf/gf/v2/errors/gerror"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/multi/api/app/user/user_ext/v1"
+)
+
+// Create add title.
+func (c *ControllerV1) Create(ctx context.Context, req *v1.CreateReq) (res *v1.CreateRes, err error) {
+	return nil, gerror.NewCode(gcode.CodeNotImplemented)
+}

cmd/gf/internal/cmd/testdata/genctrl/multi/controller/app/user/user_ext/user_ext_v1_update.go

@@ -0,0 +1,14 @@
+package user_ext
+
+import (
+	"context"
+
+	"github.com/gogf/gf/v2/errors/gcode"
+	"github.com/gogf/gf/v2/errors/gerror"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/multi/api/app/user/user_ext/v1"
+)
+
+func (c *ControllerV1) Update(ctx context.Context, req *v1.UpdateReq) (res *v1.UpdateRes, err error) {
+	return nil, gerror.NewCode(gcode.CodeNotImplemented)
+}

cmd/gf/internal/cmd/testdata/genctrl/multi/controller/app/user/user_new.go

@@ -0,0 +1,15 @@
+// =================================================================================
+// This is auto-generated by GoFrame CLI tool only once. Fill this file as you wish.
+// =================================================================================
+
+package user
+
+import (
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/multi/api/app/user"
+)
+
+type ControllerV1 struct{}
+
+func NewV1() user.IUserV1 {
+	return &ControllerV1{}
+}

cmd/gf/internal/cmd/testdata/genctrl/multi/controller/app/user/user_v1_create.go

@@ -0,0 +1,15 @@
+package user
+
+import (
+	"context"
+
+	"github.com/gogf/gf/v2/errors/gcode"
+	"github.com/gogf/gf/v2/errors/gerror"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/multi/api/app/user/v1"
+)
+
+// Create add title.
+func (c *ControllerV1) Create(ctx context.Context, req *v1.CreateReq) (res *v1.CreateRes, err error) {
+	return nil, gerror.NewCode(gcode.CodeNotImplemented)
+}

cmd/gf/internal/cmd/testdata/genctrl/multi/controller/app/user/user_v1_update.go

@@ -0,0 +1,14 @@
+package user
+
+import (
+	"context"
+
+	"github.com/gogf/gf/v2/errors/gcode"
+	"github.com/gogf/gf/v2/errors/gerror"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/multi/api/app/user/v1"
+)
+
+func (c *ControllerV1) Update(ctx context.Context, req *v1.UpdateReq) (res *v1.UpdateRes, err error) {
+	return nil, gerror.NewCode(gcode.CodeNotImplemented)
+}

cmd/gf/internal/cmd/testdata/gendao/sharding/sharding_overlapping.sql

@@ -0,0 +1,47 @@
+-- Test case for issue #4603: overlapping sharding patterns
+-- https://github.com/gogf/gf/issues/4603
+--
+-- Patterns: "a_?", "a_b_?", "a_c_?"
+-- Expected: a_1/a_2 -> "a", a_b_1/a_b_2 -> "a_b", a_c_1/a_c_2 -> "a_c"
+
+CREATE TABLE `a_1`
+(
+    `id`        int unsigned NOT NULL AUTO_INCREMENT,
+    `name`      varchar(45) NOT NULL,
+    PRIMARY KEY (`id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+
+CREATE TABLE `a_2`
+(
+    `id`        int unsigned NOT NULL AUTO_INCREMENT,
+    `name`      varchar(45) NOT NULL,
+    PRIMARY KEY (`id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+
+CREATE TABLE `a_b_1`
+(
+    `id`        int unsigned NOT NULL AUTO_INCREMENT,
+    `name`      varchar(45) NOT NULL,
+    PRIMARY KEY (`id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+
+CREATE TABLE `a_b_2`
+(
+    `id`        int unsigned NOT NULL AUTO_INCREMENT,
+    `name`      varchar(45) NOT NULL,
+    PRIMARY KEY (`id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+
+CREATE TABLE `a_c_1`
+(
+    `id`        int unsigned NOT NULL AUTO_INCREMENT,
+    `name`      varchar(45) NOT NULL,
+    PRIMARY KEY (`id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+
+CREATE TABLE `a_c_2`
+(
+    `id`        int unsigned NOT NULL AUTO_INCREMENT,
+    `name`      varchar(45) NOT NULL,
+    PRIMARY KEY (`id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;

cmd/gf/internal/cmd/testdata/gendao/tables_pattern.sql

@@ -0,0 +1,30 @@
+-- Test case for issue #4629: tables pattern matching
+-- https://github.com/gogf/gf/issues/4629
+-- Standard SQL syntax compatible with MySQL and PostgreSQL
+--
+-- Tables: trade_order, trade_item, user_info, user_log, config
+
+CREATE TABLE trade_order (
+    id   INTEGER PRIMARY KEY,
+    name VARCHAR(45) NOT NULL
+);
+
+CREATE TABLE trade_item (
+    id   INTEGER PRIMARY KEY,
+    name VARCHAR(45) NOT NULL
+);
+
+CREATE TABLE user_info (
+    id   INTEGER PRIMARY KEY,
+    name VARCHAR(45) NOT NULL
+);
+
+CREATE TABLE user_log (
+    id   INTEGER PRIMARY KEY,
+    name VARCHAR(45) NOT NULL
+);
+
+CREATE TABLE config (
+    id   INTEGER PRIMARY KEY,
+    name VARCHAR(45) NOT NULL
+);

cmd/gf/internal/cmd/testdata/genpb/multiple_tags.proto

@@ -0,0 +1,22 @@
+syntax = "proto3";
+
+package genpb;
+
+option go_package = "genpb/v1";
+
+message UserReq {
+  // v:required
+  // v:#Id > 0
+  int64 Id = 1;
+  // User name for login
+  string Name = 2;
+  // v:required
+  // v:email
+  string Email = 3; // User email address
+}
+
+message UserResp {
+  int64 Id = 1;
+  string Name = 2;
+  string Email = 3;
+}

cmd/gf/internal/cmd/testdata/genpb/nested_message.proto

@@ -0,0 +1,21 @@
+syntax = "proto3";
+
+package genpb;
+
+option go_package = "genpb/v1";
+
+message Order {
+  // v:required
+  int64 OrderId = 1;
+  // Order details
+  OrderDetail Detail = 2;
+}
+
+message OrderDetail {
+  // v:required
+  string ProductName = 1;
+  // v:min:1
+  int32 Quantity = 2;
+  // v:min:0.01
+  double Price = 3;
+}

cmd/gf/internal/cmd/testdata/issue/4242/logic/issue4242/issue4242.go

@@ -0,0 +1,34 @@
+package issue4242
+
+import (
+	"context"
+
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/net/ghttp"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/issue/4242/service"
+
+	"github.com/gogf/gf/contrib/drivers/mysql/v2"
+)
+
+func init() {
+	service.RegisterIssue4242(New())
+}
+
+type sIssue4242 struct {
+}
+
+func New() *sIssue4242 {
+	return &sIssue4242{}
+}
+
+// GetDriver tests versioned import path is preserved.
+func (s *sIssue4242) GetDriver(ctx context.Context) (d mysql.Driver, err error) {
+	return mysql.Driver{}, nil
+}
+
+// GetRequest tests another versioned import.
+func (s *sIssue4242) GetRequest(ctx context.Context) (*ghttp.Request, error) {
+	g.Log().Info(ctx, "getting request")
+	return nil, nil
+}

cmd/gf/internal/cmd/testdata/issue/4242/logic/issue4242alias/issue4242alias.go

@@ -0,0 +1,37 @@
+package issue4242alias
+
+import (
+	"context"
+
+	// Anonymous import (should be skipped)
+	_ "github.com/gogf/gf/v2/os/gres"
+
+	// Versioned import without alias
+	"github.com/gogf/gf/v2/net/ghttp"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/issue/4242/service"
+
+	// Explicit alias import
+	mysqlDriver "github.com/gogf/gf/contrib/drivers/mysql/v2"
+)
+
+func init() {
+	service.RegisterIssue4242Alias(New())
+}
+
+type sIssue4242Alias struct {
+}
+
+func New() *sIssue4242Alias {
+	return &sIssue4242Alias{}
+}
+
+// GetDriver tests explicit alias import.
+func (s *sIssue4242Alias) GetDriver(ctx context.Context) (d mysqlDriver.Driver, err error) {
+	return mysqlDriver.Driver{}, nil
+}
+
+// GetRequest tests versioned import.
+func (s *sIssue4242Alias) GetRequest(ctx context.Context) (*ghttp.Request, error) {
+	return nil, nil
+}

cmd/gf/internal/cmd/testdata/issue/4242/logic/logic.go

@@ -0,0 +1,10 @@
+// ==========================================================================
+// Code generated and maintained by GoFrame CLI tool. DO NOT EDIT.
+// ==========================================================================
+
+package logic
+
+import (
+	_ "github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/issue/4242/logic/issue4242"
+	_ "github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/issue/4242/logic/issue4242alias"
+)

cmd/gf/internal/cmd/testdata/issue/4242/service/issue_4242.go

@@ -0,0 +1,37 @@
+// ================================================================================
+// Code generated and maintained by GoFrame CLI tool. DO NOT EDIT.
+// You can delete these comments if you wish manually maintain this interface file.
+// ================================================================================
+
+package service
+
+import (
+	"context"
+
+	"github.com/gogf/gf/contrib/drivers/mysql/v2"
+	"github.com/gogf/gf/v2/net/ghttp"
+)
+
+type (
+	IIssue4242 interface {
+		// GetDriver tests versioned import path is preserved.
+		GetDriver(ctx context.Context) (d mysql.Driver, err error)
+		// GetRequest tests another versioned import.
+		GetRequest(ctx context.Context) (*ghttp.Request, error)
+	}
+)
+
+var (
+	localIssue4242 IIssue4242
+)
+
+func Issue4242() IIssue4242 {
+	if localIssue4242 == nil {
+		panic("implement not found for interface IIssue4242, forgot register?")
+	}
+	return localIssue4242
+}
+
+func RegisterIssue4242(i IIssue4242) {
+	localIssue4242 = i
+}

cmd/gf/internal/cmd/testdata/issue/4242/service/issue_4242_alias.go

@@ -0,0 +1,37 @@
+// ================================================================================
+// Code generated and maintained by GoFrame CLI tool. DO NOT EDIT.
+// You can delete these comments if you wish manually maintain this interface file.
+// ================================================================================
+
+package service
+
+import (
+	"context"
+
+	mysqlDriver "github.com/gogf/gf/contrib/drivers/mysql/v2"
+	"github.com/gogf/gf/v2/net/ghttp"
+)
+
+type (
+	IIssue4242Alias interface {
+		// GetDriver tests explicit alias import.
+		GetDriver(ctx context.Context) (d mysqlDriver.Driver, err error)
+		// GetRequest tests versioned import.
+		GetRequest(ctx context.Context) (*ghttp.Request, error)
+	}
+)
+
+var (
+	localIssue4242Alias IIssue4242Alias
+)
+
+func Issue4242Alias() IIssue4242Alias {
+	if localIssue4242Alias == nil {
+		panic("implement not found for interface IIssue4242Alias, forgot register?")
+	}
+	return localIssue4242Alias
+}
+
+func RegisterIssue4242Alias(i IIssue4242Alias) {
+	localIssue4242Alias = i
+}

cmd/gf/internal/cmd/testdata/issue/4387/api/types.go

@@ -0,0 +1,16 @@
+// Copyright GoFrame gf Author(https://goframe.org). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package api
+
+// Status is a sample enum type for testing.
+type Status int
+
+const (
+	StatusPending Status = iota
+	StatusActive
+	StatusDone
+)

cmd/gf/internal/cmd/testdata/issue/4387/go.mod

@@ -0,0 +1,5 @@
+module github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/issue/4387
+
+go 1.23.0
+
+toolchain go1.24.12

container/garray/garray_normal_t.go

@@ -749,7 +749,9 @@ func (a *TArray[T]) String() string {
 }
 
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
-// Note that do not use pointer as its receiver here.
+// DO NOT change this receiver to pointer type, as the TArray can be used as a var defined variable, like:
+// var a TArray[int]
+// Please refer to corresponding tests for more details.
 func (a TArray[T]) MarshalJSON() ([]byte, error) {
 	a.mu.RLock()
 	defer a.mu.RUnlock()

container/garray/garray_sorted_t.go

@@ -46,7 +46,7 @@ func NewSortedTArray[T comparable](comparator func(a, b T) int, safe ...bool) *S
 	return NewSortedTArraySize(0, comparator, safe...)
 }
 
-// NewSortedTArraySize create and returns an sorted array with given size and cap.
+// NewSortedTArraySize create and returns a sorted array with given size and cap.
 // The parameter `safe` is used to specify whether using array in concurrent-safety,
 // which is false in default.
 func NewSortedTArraySize[T comparable](cap int, comparator func(a, b T) int, safe ...bool) *SortedTArray[T] {
@@ -718,7 +718,9 @@ func (a *SortedTArray[T]) String() string {
 }
 
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
-// Note that do not use pointer as its receiver here.
+// DO NOT change this receiver to pointer type, as the TArray can be used as a var defined variable, like:
+// var a SortedTArray[int]
+// Please refer to corresponding tests for more details.
 func (a SortedTArray[T]) MarshalJSON() ([]byte, error) {
 	a.mu.RLock()
 	defer a.mu.RUnlock()

container/gmap/gmap_hash_k_v_map.go

@@ -17,19 +17,32 @@ import (
 	"github.com/gogf/gf/v2/util/gconv"
 )
 
+// NilChecker is a function that checks whether the given value is nil.
+type NilChecker[V any] func(V) bool
+
 // KVMap wraps map type `map[K]V` and provides more map features.
 type KVMap[K comparable, V any] struct {
 	mu   rwmutex.RWMutex
 	data map[K]V
+
+	// nilChecker is the custom nil checker function.
+	// It uses empty.IsNil if it's nil.
+	nilChecker NilChecker[V]
 }
 
 // NewKVMap creates and returns an empty hash map.
-// The parameter `safe` is used to specify whether to use the map in concurrent-safety mode,
-// which is false by default.
+// The parameter `safe` is used to specify whether to use the map in concurrent-safety mode, which is false by default.
 func NewKVMap[K comparable, V any](safe ...bool) *KVMap[K, V] {
 	return NewKVMapFrom(make(map[K]V), safe...)
 }
 
+// NewKVMapWithChecker creates and returns an empty hash map with a custom nil checker.
+// The parameter `checker` is a function used to determine if a value is nil.
+// The parameter `safe` is used to specify whether to use the map in concurrent-safety mode, which is false by default.
+func NewKVMapWithChecker[K comparable, V any](checker NilChecker[V], safe ...bool) *KVMap[K, V] {
+	return NewKVMapWithCheckerFrom(make(map[K]V), checker, safe...)
+}
+
 // NewKVMapFrom creates and returns a hash map from given map `data`.
 // Note that, the param `data` map will be set as the underlying data map (no deep copy),
 // there might be some concurrent-safe issues when changing the map outside.
@@ -41,6 +54,37 @@ func NewKVMapFrom[K comparable, V any](data map[K]V, safe ...bool) *KVMap[K, V]
 	return m
 }
 
+// NewKVMapWithCheckerFrom creates and returns a hash map from given map `data` with a custom nil checker.
+// Note that, the param `data` map will be set as the underlying data map (no deep copy),
+// and there might be some concurrent-safe issues when changing the map outside.
+// The parameter `checker` is a function used to determine if a value is nil.
+// The parameter `safe` is used to specify whether to use the map in concurrent-safety mode, which is false by default.
+func NewKVMapWithCheckerFrom[K comparable, V any](data map[K]V, checker NilChecker[V], safe ...bool) *KVMap[K, V] {
+	m := NewKVMapFrom[K, V](data, safe...)
+	m.SetNilChecker(checker)
+	return m
+}
+
+// SetNilChecker registers a custom nil checker function for the map values.
+// This function is used to determine if a value should be considered as nil.
+// The nil checker function takes a value of type V and returns a boolean indicating
+// whether the value should be treated as nil.
+func (m *KVMap[K, V]) SetNilChecker(nilChecker NilChecker[V]) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	m.nilChecker = nilChecker
+}
+
+// isNil checks whether the given value is nil.
+// It first checks if a custom nil checker function is registered and uses it if available,
+// otherwise it falls back to the default empty.IsNil function.
+func (m *KVMap[K, V]) isNil(v V) bool {
+	if m.nilChecker != nil {
+		return m.nilChecker(v)
+	}
+	return empty.IsNil(v)
+}
+
 // Iterator iterates the hash map readonly with custom callback function `f`.
 // If `f` returns true, then it continues iterating; or false to stop.
 func (m *KVMap[K, V]) Iterator(f func(k K, v V) bool) {
@@ -201,11 +245,12 @@ func (m *KVMap[K, V]) Pops(size int) map[K]V {
 	return newMap
 }
 
-// doSetWithLockCheck checks whether value of the key exists with mutex.Lock,
-// if not exists, set value to the map with given `key`,
-// or else just return the existing value.
+// doSetWithLockCheck sets value with given `value` if it does not exist,
+// and then returns this value and whether it exists.
 //
-// It returns value with given `key`.
+// It is a helper function for GetOrSet* functions.
+//
+// Note that, it does not add the value to the map if the given `value` is nil.
 func (m *KVMap[K, V]) doSetWithLockCheck(key K, value V) (val V, ok bool) {
 	m.mu.Lock()
 	defer m.mu.Unlock()
@@ -217,8 +262,7 @@ func (m *KVMap[K, V]) doSetWithLockCheck(key K, value V) (val V, ok bool) {
 	if v, ok := m.data[key]; ok {
 		return v, true
 	}
-
-	if any(value) != nil {
+	if !m.isNil(value) {
 		m.data[key] = value
 	}
 	return value, false
@@ -234,6 +278,8 @@ func (m *KVMap[K, V]) GetOrSet(key K, value V) V {
 // GetOrSetFunc returns the value by key,
 // or sets value with returned value of callback function `f` if it does not exist
 // and then returns this value.
+//
+// Note that, it does not add the value to the map if the returned value of `f` is nil.
 func (m *KVMap[K, V]) GetOrSetFunc(key K, f func() V) V {
 	v, _ := m.doSetWithLockCheck(key, f())
 	return v
@@ -245,6 +291,8 @@ func (m *KVMap[K, V]) GetOrSetFunc(key K, f func() V) V {
 //
 // GetOrSetFuncLock differs with GetOrSetFunc function is that it executes function `f`
 // with mutex.Lock of the hash map.
+//
+// Note that, it does not add the value to the map if the returned value of `f` is nil.
 func (m *KVMap[K, V]) GetOrSetFuncLock(key K, f func() V) V {
 	m.mu.Lock()
 	defer m.mu.Unlock()
@@ -255,7 +303,7 @@ func (m *KVMap[K, V]) GetOrSetFuncLock(key K, f func() V) V {
 		return v
 	}
 	value := f()
-	if any(value) != nil {
+	if !m.isNil(value) {
 		m.data[key] = value
 	}
 	return value
@@ -484,6 +532,9 @@ func (m *KVMap[K, V]) String() string {
 }
 
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
+// DO NOT change this receiver to pointer type, as the KVMap can be used as a var defined variable, like:
+// var m gmap.KVMap[int, string]
+// Please refer to corresponding tests for more details.
 func (m KVMap[K, V]) MarshalJSON() ([]byte, error) {
 	return json.Marshal(gconv.Map(m.Map()))
 }

container/gmap/gmap_list_k_v_map.go

@@ -27,9 +27,10 @@ import (
 //
 // Reference: http://en.wikipedia.org/wiki/Associative_array
 type ListKVMap[K comparable, V any] struct {
-	mu   rwmutex.RWMutex
-	data map[K]*glist.TElement[*gListKVMapNode[K, V]]
-	list *glist.TList[*gListKVMapNode[K, V]]
+	mu         rwmutex.RWMutex
+	data       map[K]*glist.TElement[*gListKVMapNode[K, V]]
+	list       *glist.TList[*gListKVMapNode[K, V]]
+	nilChecker NilChecker[V]
 }
 
 type gListKVMapNode[K comparable, V any] struct {
@@ -49,6 +50,16 @@ func NewListKVMap[K comparable, V any](safe ...bool) *ListKVMap[K, V] {
 	}
 }
 
+// NewListKVMapWithChecker creates and returns a new ListKVMap instance with a custom nil checker.
+// The parameter `checker` is a function used to determine if a value is nil.
+// The parameter `safe` is used to specify whether using map in concurrent-safety,
+// which is false by default.
+func NewListKVMapWithChecker[K comparable, V any](checker NilChecker[V], safe ...bool) *ListKVMap[K, V] {
+	m := NewListKVMap[K, V](safe...)
+	m.SetNilChecker(checker)
+	return m
+}
+
 // NewListKVMapFrom returns a link map from given map `data`.
 // Note that, the param `data` map will be copied to the underlying data structure,
 // so changes to the original map will not affect the link map.
@@ -58,6 +69,38 @@ func NewListKVMapFrom[K comparable, V any](data map[K]V, safe ...bool) *ListKVMa
 	return m
 }
 
+// NewListKVMapWithCheckerFrom returns a link map from given map `data` with a custom nil checker.
+// Note that, the param `data` map will be copied to the underlying data structure,
+// so changes to the original map will not affect the link map.
+// The parameter `checker` is a function used to determine if a value is nil.
+// The parameter `safe` is used to specify whether using map in concurrent-safety,
+// which is false by default.
+func NewListKVMapWithCheckerFrom[K comparable, V any](data map[K]V, nilChecker NilChecker[V], safe ...bool) *ListKVMap[K, V] {
+	m := NewListKVMapWithChecker[K, V](nilChecker, safe...)
+	m.Sets(data)
+	return m
+}
+
+// SetNilChecker registers a custom nil checker function for the map values.
+// This function is used to determine if a value should be considered as nil.
+// The nil checker function takes a value of type V and returns a boolean indicating
+// whether the value should be treated as nil.
+func (m *ListKVMap[K, V]) SetNilChecker(nilChecker NilChecker[V]) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	m.nilChecker = nilChecker
+}
+
+// isNil checks whether the given value is nil.
+// It first checks if a custom nil checker function is registered and uses it if available,
+// otherwise it falls back to the default empty.IsNil function.
+func (m *ListKVMap[K, V]) isNil(v V) bool {
+	if m.nilChecker != nil {
+		return m.nilChecker(v)
+	}
+	return empty.IsNil(v)
+}
+
 // Iterator is alias of IteratorAsc.
 func (m *ListKVMap[K, V]) Iterator(f func(key K, value V) bool) {
 	m.IteratorAsc(f)
@@ -282,7 +325,7 @@ func (m *ListKVMap[K, V]) doSetWithLockCheckWithoutLock(key K, value V) V {
 	if e, ok := m.data[key]; ok {
 		return e.Value.value
 	}
-	if any(value) != nil {
+	if !m.isNil(value) {
 		m.data[key] = m.list.PushBack(&gListKVMapNode[K, V]{key, value})
 	}
 	return value
@@ -327,7 +370,7 @@ func (m *ListKVMap[K, V]) GetOrSetFuncLock(key K, f func() V) V {
 		return e.Value.value
 	}
 	value := f()
-	if any(value) != nil {
+	if !m.isNil(value) {
 		m.data[key] = m.list.PushBack(&gListKVMapNode[K, V]{key, value})
 	}
 	return value
@@ -359,6 +402,8 @@ func (m *ListKVMap[K, V]) GetVarOrSetFuncLock(key K, f func() V) *gvar.Var {
 
 // SetIfNotExist sets `value` to the map if the `key` does not exist, and then returns true.
 // It returns false if `key` exists, and `value` would be ignored.
+//
+// Note that it does not add the value to the map if `value` is nil.
 func (m *ListKVMap[K, V]) SetIfNotExist(key K, value V) bool {
 	m.mu.Lock()
 	defer m.mu.Unlock()
@@ -370,7 +415,7 @@ func (m *ListKVMap[K, V]) SetIfNotExist(key K, value V) bool {
 	if _, ok := m.data[key]; ok {
 		return false
 	}
-	if any(value) != nil {
+	if !m.isNil(value) {
 		m.data[key] = m.list.PushBack(&gListKVMapNode[K, V]{key, value})
 	}
 	return true
@@ -378,6 +423,8 @@ func (m *ListKVMap[K, V]) SetIfNotExist(key K, value V) bool {
 
 // SetIfNotExistFunc sets value with return value of callback function `f`, and then returns true.
 // It returns false if `key` exists, and `value` would be ignored.
+//
+// Note that, it does not add the value to the map if the returned value of `f` is nil.
 func (m *ListKVMap[K, V]) SetIfNotExistFunc(key K, f func() V) bool {
 	m.mu.Lock()
 	defer m.mu.Unlock()
@@ -390,7 +437,7 @@ func (m *ListKVMap[K, V]) SetIfNotExistFunc(key K, f func() V) bool {
 		return false
 	}
 	value := f()
-	if any(value) != nil {
+	if !m.isNil(value) {
 		m.data[key] = m.list.PushBack(&gListKVMapNode[K, V]{key, value})
 	}
 	return true
@@ -401,6 +448,8 @@ func (m *ListKVMap[K, V]) SetIfNotExistFunc(key K, f func() V) bool {
 //
 // SetIfNotExistFuncLock differs with SetIfNotExistFunc function is that
 // it executes function `f` with mutex.Lock of the map.
+//
+// Note that, it does not add the value to the map if the returned value of `f` is nil.
 func (m *ListKVMap[K, V]) SetIfNotExistFuncLock(key K, f func() V) bool {
 	m.mu.Lock()
 	defer m.mu.Unlock()
@@ -413,7 +462,7 @@ func (m *ListKVMap[K, V]) SetIfNotExistFuncLock(key K, f func() V) bool {
 		return false
 	}
 	value := f()
-	if any(value) != nil {
+	if !m.isNil(value) {
 		m.data[key] = m.list.PushBack(&gListKVMapNode[K, V]{key, value})
 	}
 	return true
@@ -566,6 +615,9 @@ func (m *ListKVMap[K, V]) String() string {
 }
 
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
+// DO NOT change this receiver to pointer type, as the ListKVMap can be used as a var defined variable, like:
+// var m gmap.ListKVMap[string]string
+// Please refer to corresponding tests for more details.
 func (m ListKVMap[K, V]) MarshalJSON() (jsonBytes []byte, err error) {
 	if m.data == nil {
 		return []byte("{}"), nil