Go CLI: refactor commands (#16213)

### What problem does this PR solve? As title. ### Type of change - [x] Refactoring --------- Signed-off-by: Jin Hai <haijin.chn@gmail.com>
2026-09-07 17:58:55 +08:00 · 2026-06-21 16:50:02 +08:00
parent 1b712be599
commit 5039f46999
10 changed files with 537 additions and 629 deletions
--- a/internal/cli/admin_parser.go
+++ b/internal/cli/admin_parser.go
@@ -69,7 +69,7 @@ func (p *Parser) parseAdminLogout() (*Command, error) {
 }

 func (p *Parser) parseAdminPingServer() (*Command, error) {
-	cmd := NewCommand("ping")
+	cmd := NewCommand("ping_server")
 	p.nextToken()
 	// Semicolon is optional for UNSET TOKEN
 	if p.curToken.Type == TokenSemicolon {
@@ -78,53 +78,6 @@ func (p *Parser) parseAdminPingServer() (*Command, error) {
 	return cmd, nil
 }

-func (p *Parser) parseAdminRegisterCommand() (*Command, error) {
-	cmd := NewCommand("register_user")
-
-	if err := p.expectPeek(TokenUser); err != nil {
-		return nil, err
-	}
-	p.nextToken()
-
-	userName, err := p.parseQuotedString()
-	if err != nil {
-		return nil, err
-	}
-	cmd.Params["user_name"] = userName
-
-	p.nextToken()
-	if p.curToken.Type != TokenAs {
-		return nil, fmt.Errorf("expected AS")
-	}
-
-	p.nextToken()
-	nickname, err := p.parseQuotedString()
-	if err != nil {
-		return nil, err
-	}
-	cmd.Params["nickname"] = nickname
-
-	p.nextToken()
-	if p.curToken.Type != TokenPassword {
-		return nil, fmt.Errorf("expected PASSWORD")
-	}
-
-	p.nextToken()
-	password, err := p.parseQuotedString()
-	if err != nil {
-		return nil, err
-	}
-	cmd.Params["password"] = password
-
-	p.nextToken()
-	// Semicolon is optional for UNSET TOKEN
-	if p.curToken.Type == TokenSemicolon {
-		p.nextToken()
-	}
-
-	return cmd, nil
-}
-
 // endregion

 // region LIST commands
@@ -133,29 +86,15 @@ func (p *Parser) parseAdminListCommand() (*Command, error) {

 	switch p.curToken.Type {
 	case TokenServices:
-		p.nextToken()
-		// Semicolon is optional for SHOW TOKEN
-		if p.curToken.Type == TokenSemicolon {
-			p.nextToken()
-		}
-		return NewCommand("list_services"), nil
+		return p.parseAdminListServices()
 	case TokenUsers:
 		return p.parseAdminListUsersCommand()
-	case TokenDatasets:
-		return p.parseAdminListDatasets()
-	case TokenAgents:
-		return p.parseAdminListAgents()
 	case TokenRoles:
 		return p.parseAdminListRoles()
 	case TokenResources:
 		return p.parseAdminListResources()
 	case TokenVars:
-		p.nextToken()
-		// Semicolon is optional for SHOW TOKEN
-		if p.curToken.Type == TokenSemicolon {
-			p.nextToken()
-		}
-		return NewCommand("list_variables"), nil
+		return p.parseAdminListVariables()
 	case TokenConfigs:
 		p.nextToken()
 		// Semicolon is optional for SHOW TOKEN
@@ -172,8 +111,10 @@ func (p *Parser) parseAdminListCommand() (*Command, error) {
 		return NewCommand("list_environments"), nil
 	case TokenAvailable:
 		return p.parseCommonListProviders()
+	case TokenProvider:
+		return p.parseAdminListProvider()
 	case TokenModels:
-		return p.parseListModelsOfProvider()
+		return p.parseAdminListModels()
 	case TokenUser:
 		return p.parseAdminListUserCommand()
 	case TokenTokens:
@@ -202,58 +143,14 @@ func (p *Parser) parseAdminListCommand() (*Command, error) {
 	}
 }

-func (p *Parser) parseAdminListDatasets() (*Command, error) {
-	cmd := NewCommand("list_user_datasets")
-	p.nextToken() // consume DATASETS
+func (p *Parser) parseAdminListServices() (*Command, error) {
+	p.nextToken() // consume SERVICES

 	if p.curToken.Type == TokenSemicolon {
-		return cmd, nil
-	}
-
-	if p.curToken.Type == TokenOf {
-		p.nextToken()
-		userName, err := p.parseQuotedString()
-		if err != nil {
-			return nil, err
-		}
-		cmd = NewCommand("list_datasets")
-		cmd.Params["user_name"] = userName
 		p.nextToken()
 	}

-	// Semicolon is optional for UNSET TOKEN
-	if p.curToken.Type == TokenSemicolon {
-		p.nextToken()
-	}
-	return cmd, nil
-}
-
-func (p *Parser) parseAdminListAgents() (*Command, error) {
-	p.nextToken() // consume AGENTS
-
-	if p.curToken.Type == TokenSemicolon {
-		return NewCommand("list_user_agents"), nil
-	}
-
-	if p.curToken.Type != TokenOf {
-		return nil, fmt.Errorf("expected OF")
-	}
-	p.nextToken()
-
-	userName, err := p.parseQuotedString()
-	if err != nil {
-		return nil, err
-	}
-
-	cmd := NewCommand("list_agents")
-	cmd.Params["user_name"] = userName
-
-	p.nextToken()
-	// Semicolon is optional for UNSET TOKEN
-	if p.curToken.Type == TokenSemicolon {
-		p.nextToken()
-	}
-	return cmd, nil
+	return NewCommand("admin_list_services"), nil
 }

 func (p *Parser) parseAdminListRoles() (*Command, error) {
@@ -276,6 +173,16 @@ func (p *Parser) parseAdminListResources() (*Command, error) {
 	return NewCommand("admin_list_resources_command"), nil
 }

+func (p *Parser) parseAdminListVariables() (*Command, error) {
+	p.nextToken() // consume VARIABLES
+
+	// Semicolon is optional
+	if p.curToken.Type == TokenSemicolon {
+		p.nextToken()
+	}
+	return NewCommand("admin_list_variables"), nil
+}
+
 func (p *Parser) parseAdminListTokens() (*Command, error) {
 	p.nextToken() // consume TOKENS
 	cmd := NewCommand("list_tokens")
@@ -375,6 +282,40 @@ func (p *Parser) parseAdminListIngestionTasks() (*Command, error) {
 	return cmd, nil
 }

+// LIST PROVIDER 'provider_name' MODELS;
+func (p *Parser) parseAdminListProvider() (*Command, error) {
+	p.nextToken() // consume PROVIDER
+
+	providerName, err := p.parseQuotedString()
+	if err != nil {
+		return nil, err
+	}
+	p.nextToken()
+
+	if p.curToken.Type != TokenModels {
+		return nil, fmt.Errorf("expected MODELS")
+	}
+	p.nextToken() // consume MODELS
+	cmd := NewCommand("admin_list_provider_models")
+	cmd.Params["provider_name"] = providerName
+
+	if p.curToken.Type == TokenSemicolon {
+		p.nextToken()
+	}
+	return cmd, nil
+}
+
+func (p *Parser) parseAdminListModels() (*Command, error) {
+	p.nextToken() // consume MODELS
+	cmd := NewCommand("admin_list_all_models")
+
+	if p.curToken.Type == TokenSemicolon {
+		p.nextToken()
+	}
+
+	return cmd, nil
+}
+
 // endregion LIST commands

 // region SHOW commands
@@ -384,25 +325,25 @@ func (p *Parser) parseAdminShowCommand() (*Command, error) {

 	switch p.curToken.Type {
 	case TokenService:
-		return p.parseShowService()
+		return p.parseAdminShowService()
 	case TokenUser:
-		return p.parseAdminShowUserCommand()
+		return p.parseAdminShowUserCommands()
 	case TokenRole:
-		return p.parseAdminShowRoleCommand()
+		return p.parseAdminShowRole()
 	case TokenVersion:
-		return p.parseAdminShowVersionCommand()
+		return p.parseAdminShowVersion()
 	case TokenVar:
-		return p.parseShowVariable()
+		return p.parseAdminShowVariable()
 	case TokenCurrent:
-		return p.parseAdminShowCurrentCommand()
+		return p.parseAdminShowCurrent()
 	case TokenFingerprint:
-		return p.parseAdminShowFingerprintCommand()
+		return p.parseAdminShowFingerprint()
 	case TokenLicense:
-		return p.parseAdminShowLicenseCommand()
+		return p.parseAdminShowLicense()
 	case TokenProvider:
-		return p.parseShowProvider()
+		return p.parseAdminShowProvider()
 	case TokenModel:
-		return p.parseShowModel()
+		return p.parseAdminShowModel()
 	case TokenAdmin:
 		return p.parseUserShowAdmin()
 	case TokenAPI:
@@ -414,39 +355,21 @@ func (p *Parser) parseAdminShowCommand() (*Command, error) {
 	case TokenQuota:
 		return p.parseAdminShowQuotaCommand()
 	case TokenTasks:
-		return p.parseAdminShowQuotaCommand()
+		return p.parseAdminShowTasksCommand()
 	default:
 		return nil, fmt.Errorf("unknown SHOW target: %s", p.curToken.Value)
 	}
 }

-func (p *Parser) parseAdminShowUser() (*Command, error) {
-	p.nextToken() // consume USER
-
-	// Check for PERMISSION
-	if p.curToken.Type == TokenPermission {
-		p.nextToken()
-		userName, err := p.parseQuotedString()
-		if err != nil {
-			return nil, err
-		}
-		cmd := NewCommand("show_user_permission")
-		cmd.Params["user_name"] = userName
-		p.nextToken()
-		// Semicolon is optional for SHOW TOKEN
-		if p.curToken.Type == TokenSemicolon {
-			p.nextToken()
-		}
-		return cmd, nil
-	}
-
-	userName, err := p.parseQuotedString()
+func (p *Parser) parseAdminShowService() (*Command, error) {
+	p.nextToken() // consume SERVICE
+	serviceNum, err := p.parseNumber()
 	if err != nil {
 		return nil, err
 	}

-	cmd := NewCommand("show_user")
-	cmd.Params["user_name"] = userName
+	cmd := NewCommand("admin_show_service")
+	cmd.Params["number"] = serviceNum

 	p.nextToken()
 	// Semicolon is optional for UNSET TOKEN
@@ -456,14 +379,209 @@ func (p *Parser) parseAdminShowUser() (*Command, error) {
 	return cmd, nil
 }

-func (p *Parser) parseAdminShowRoleCommand() (*Command, error) {
+// SHOW USER 'user@example.com';
+// SHOW USER 'user@example.com' ACTIVITY;
+// SHOW USER 'user@example.com' SUMMARY;
+// SHOW USER 'user@example.com' DATASET 'dataset_name';
+// SHOW USER 'user@example.com' STORAGE;
+// SHOW USER 'user@example.com' QUOTA;
+// SHOW USER 'user@example.com' INDEX;
+// SHOW USER 'user@example.com' PERMISSION;
+func (p *Parser) parseAdminShowUserCommands() (*Command, error) {
+	p.nextToken() // consume USER
+
+	userName, err := p.parseQuotedString()
+	if err != nil {
+		return nil, err
+	}
+	p.nextToken()
+
+	switch p.curToken.Type {
+	case TokenActivity:
+		return p.parseAdminShowActivityCommand(userName)
+	case TokenSummary:
+		return p.parseAdminShowUserSummaryCommand(userName)
+	case TokenDataset:
+		return p.parseAdminShowUserDataSetCommand(userName)
+	case TokenStorage:
+		return p.parseAdminShowUserStorageCommand(userName)
+	case TokenQuota:
+		return p.parseAdminShowUserQuotaCommand(userName)
+	case TokenIndex:
+		return p.parseAdminShowUserIndexCommand(userName)
+	case TokenPermission:
+		return p.parseAdminShowUserPermissionCommand(userName)
+	default:
+		return p.parseAdminShowUser(userName)
+	}
+}
+
+// SHOW USER 'user@example.com';
+func (p *Parser) parseAdminShowUser(userName string) (*Command, error) {
+
+	// Semicolon is optional
+	if p.curToken.Type == TokenSemicolon {
+		p.nextToken()
+	}
+
+	cmd := NewCommand("admin_show_user")
+	cmd.Params["user_name"] = userName
+
+	return cmd, nil
+}
+
+// SHOW USER 'user@example.com' ACTIVITY DAYS 30;
+func (p *Parser) parseAdminShowActivityCommand(userName string) (*Command, error) {
+	p.nextToken() // consume ACTIVITY
+
+	var days int
+	var err error
+
+	if p.curToken.Type == TokenDays {
+		p.nextToken() // consume DAYS
+		days, err = p.parseNumber()
+		if err != nil {
+			return nil, err
+		}
+		if days < 1 {
+			return nil, fmt.Errorf("invalid number of DAYS")
+		}
+		p.nextToken()
+	} else {
+		days = 7
+	}
+
+	// Semicolon is optional
+	if p.curToken.Type == TokenSemicolon {
+		p.nextToken()
+	}
+
+	cmd := NewCommand("admin_show_user_activity_command")
+	cmd.Params["user_name"] = userName
+	cmd.Params["days"] = days
+
+	return cmd, nil
+}
+
+// SHOW USER 'user@example.com' SUMMARY;
+func (p *Parser) parseAdminShowUserSummaryCommand(userName string) (*Command, error) {
+	p.nextToken() // consume SUMMARY
+
+	cmd := NewCommand("admin_show_user_summary_command")
+	cmd.Params["user_name"] = userName
+
+	// Semicolon is optional
+	if p.curToken.Type == TokenSemicolon {
+		p.nextToken()
+	}
+
+	return cmd, nil
+}
+
+// SHOW USER 'user@example.com' DATASET 'dataset_name';
+func (p *Parser) parseAdminShowUserDataSetCommand(userName string) (*Command, error) {
+	p.nextToken() // consume DATASET
+
+	var tree = false
+	var datasetName string
+	var err error
+	datasetName, err = p.parseQuotedString()
+	if err != nil {
+		return nil, err
+	}
+	p.nextToken()
+
+	if p.curToken.Type == TokenTree {
+		tree = true
+		p.nextToken()
+	}
+
+	cmd := NewCommand("admin_show_user_dataset_command")
+	cmd.Params["user_name"] = userName
+	if datasetName != "" {
+		cmd.Params["dataset_name"] = datasetName
+	}
+	if tree {
+		cmd.Params["tree"] = true
+	}
+
+	// Semicolon is optional
+	if p.curToken.Type == TokenSemicolon {
+		p.nextToken()
+	}
+
+	return cmd, nil
+}
+
+// SHOW USER 'user@example.com' STORAGE;
+func (p *Parser) parseAdminShowUserStorageCommand(userName string) (*Command, error) {
+	p.nextToken() // consume STORAGE
+
+	cmd := NewCommand("admin_show_user_storage_command")
+	cmd.Params["user_name"] = userName
+
+	// Semicolon is optional
+	if p.curToken.Type == TokenSemicolon {
+		p.nextToken()
+	}
+
+	return cmd, nil
+}
+
+// SHOW USER 'user@example.com' QUOTA;
+func (p *Parser) parseAdminShowUserQuotaCommand(userName string) (*Command, error) {
+	p.nextToken() // consume QUOTA
+
+	cmd := NewCommand("admin_show_user_quota_command")
+	cmd.Params["user_name"] = userName
+
+	// Semicolon is optional
+	if p.curToken.Type == TokenSemicolon {
+		p.nextToken()
+	}
+
+	return cmd, nil
+}
+
+// SHOW USER 'user@example.com' INDEX;
+func (p *Parser) parseAdminShowUserIndexCommand(userName string) (*Command, error) {
+	p.nextToken() // consume INDEX
+
+	cmd := NewCommand("admin_show_user_index_command")
+	cmd.Params["user_name"] = userName
+
+	// Semicolon is optional
+	if p.curToken.Type == TokenSemicolon {
+		p.nextToken()
+	}
+
+	return cmd, nil
+}
+
+// SHOW USER 'user@example.com' PERMISSION;
+func (p *Parser) parseAdminShowUserPermissionCommand(userName string) (*Command, error) {
+	p.nextToken() // consume PERMISSION
+
+	cmd := NewCommand("admin_show_user_permission_command")
+	cmd.Params["user_name"] = userName
+
+	// Semicolon is optional
+	if p.curToken.Type == TokenSemicolon {
+		p.nextToken()
+	}
+	return cmd, nil
+}
+
+// SHOW ROLE 'role_name';
+func (p *Parser) parseAdminShowRole() (*Command, error) {
 	p.nextToken() // consume ROLE
-	roleName, err := p.parseIdentifier()
+
+	roleName, err := p.parseQuotedString()
 	if err != nil {
 		return nil, err
 	}

-	cmd := NewCommand("show_role")
+	cmd := NewCommand("admin_show_role")
 	cmd.Params["role_name"] = roleName

 	p.nextToken()
@@ -474,14 +592,27 @@ func (p *Parser) parseAdminShowRoleCommand() (*Command, error) {
 	return cmd, nil
 }

+// SHOW VERSION;
+func (p *Parser) parseAdminShowVersion() (*Command, error) {
+	p.nextToken() // consume VERSION
+
+	// Semicolon is optional
+	if p.curToken.Type == TokenSemicolon {
+		p.nextToken()
+	}
+
+	return NewCommand("admin_show_version_command"), nil
+}
+
+// SHOW VAR 'var_name';
 func (p *Parser) parseAdminShowVariable() (*Command, error) {
 	p.nextToken() // consume VAR
-	varName, err := p.parseIdentifier()
+	varName, err := p.parseQuotedString()
 	if err != nil {
 		return nil, err
 	}

-	cmd := NewCommand("show_variable")
+	cmd := NewCommand("admin_show_variable")
 	cmd.Params["var_name"] = varName

 	p.nextToken()
@@ -492,21 +623,105 @@ func (p *Parser) parseAdminShowVariable() (*Command, error) {
 	return cmd, nil
 }

-func (p *Parser) parseAdminShowService() (*Command, error) {
-	p.nextToken() // consume SERVICE
-	serviceNum, err := p.parseNumber()
-	if err != nil {
-		return nil, err
-	}
+// SHOW CURRENT;
+func (p *Parser) parseAdminShowCurrent() (*Command, error) {
+	p.nextToken() // consume CURRENT

-	cmd := NewCommand("show_service")
-	cmd.Params["number"] = serviceNum
-
-	p.nextToken()
-	// Semicolon is optional for UNSET TOKEN
+	// Semicolon is optional
 	if p.curToken.Type == TokenSemicolon {
 		p.nextToken()
 	}
+
+	return NewCommand("admin_show_current"), nil
+}
+
+// SHOW FINGERPRINT;
+func (p *Parser) parseAdminShowFingerprint() (*Command, error) {
+	p.nextToken() // consume FINGERPRINT
+
+	// Semicolon is optional
+	if p.curToken.Type == TokenSemicolon {
+		p.nextToken()
+	}
+
+	return NewCommand("admin_show_fingerprint"), nil
+}
+
+// SHOW LICENSE;
+func (p *Parser) parseAdminShowLicense() (*Command, error) {
+	p.nextToken() // consume LICENSE
+
+	// Semicolon is optional
+	if p.curToken.Type == TokenSemicolon {
+		p.nextToken()
+	}
+
+	return NewCommand("admin_show_license"), nil
+}
+
+// SHOW PROVIDER 'provider_name';
+func (p *Parser) parseAdminShowProvider() (*Command, error) {
+	p.nextToken() // consume PROVIDER
+
+	providerName, err := p.parseQuotedString()
+	if err != nil {
+		return nil, fmt.Errorf("expected provider name: %w", err)
+	}
+	p.nextToken()
+
+	if p.curToken.Type == TokenModel {
+		// SHOW PROVIDER 'provider_name' MODEL 'model_name'
+		return p.parseAdminShowProviderModel(providerName)
+	}
+
+	// Semicolon is optional
+	if p.curToken.Type == TokenSemicolon {
+		p.nextToken()
+	}
+
+	cmd := NewCommand("admin_show_provider")
+	cmd.Params["provider_name"] = providerName
+	return cmd, nil
+}
+
+// SHOW PROVIDER 'provider_name' MODEL 'model_name';
+func (p *Parser) parseAdminShowProviderModel(providerName string) (*Command, error) {
+	p.nextToken() // consume MODEL
+
+	modelName, err := p.parseQuotedString()
+	if err != nil {
+		return nil, fmt.Errorf("expected model name: %w", err)
+	}
+	p.nextToken() // consume model_name
+
+	cmd := NewCommand("admin_show_provider_model")
+	cmd.Params["model_name"] = modelName
+	cmd.Params["provider_name"] = providerName
+
+	// Semicolon is optional
+	if p.curToken.Type == TokenSemicolon {
+		p.nextToken()
+	}
+	return cmd, nil
+}
+
+// SHOW MODEL 'model_name';
+func (p *Parser) parseAdminShowModel() (*Command, error) {
+	p.nextToken() // consume MODEL
+
+	modelName, err := p.parseQuotedString()
+	if err != nil {
+		return nil, fmt.Errorf("expected model name: %w", err)
+	}
+	p.nextToken()
+
+	// Semicolon is optional
+	if p.curToken.Type == TokenSemicolon {
+		p.nextToken()
+	}
+
+	cmd := NewCommand("admin_show_model")
+	cmd.Params["model_name"] = modelName
 	return cmd, nil
 }

@@ -2024,243 +2239,6 @@ func (p *Parser) parseAdminRemoveCommand() (*Command, error) {
 	return cmd, nil
 }

-// SHOW VERSION;
-func (p *Parser) parseAdminShowVersionCommand() (*Command, error) {
-	p.nextToken() // consume VERSION
-
-	// Semicolon is optional
-	if p.curToken.Type == TokenSemicolon {
-		p.nextToken()
-	}
-
-	return NewCommand("admin_show_version_command"), nil
-}
-
-// SHOW CURRENT;
-func (p *Parser) parseAdminShowCurrentCommand() (*Command, error) {
-	p.nextToken() // consume CURRENT
-
-	// Semicolon is optional
-	if p.curToken.Type == TokenSemicolon {
-		p.nextToken()
-	}
-
-	return NewCommand("show_current"), nil
-}
-
-func (p *Parser) parseAdminShowFingerprintCommand() (*Command, error) {
-	p.nextToken() // consume FINGERPRINT
-
-	// Semicolon is optional
-	if p.curToken.Type == TokenSemicolon {
-		p.nextToken()
-	}
-
-	return NewCommand("admin_show_fingerprint_command"), nil
-}
-
-func (p *Parser) parseAdminShowLicenseCommand() (*Command, error) {
-	p.nextToken() // consume LICENSE
-
-	// Semicolon is optional
-	if p.curToken.Type == TokenSemicolon {
-		p.nextToken()
-	}
-
-	return NewCommand("admin_show_license_command"), nil
-}
-
-// SHOW USER 'user@example.com';
-// SHOW USER 'user@example.com' DATASET 'dataset_name';
-// SHOW USER 'user@example.com' SUMMARY;
-// SHOW USER 'user@example.com' STORAGE;
-// SHOW USER 'user@example.com' QUOTA;
-// SHOW USER 'user@example.com' INDEX;
-func (p *Parser) parseAdminShowUserCommand() (*Command, error) {
-	p.nextToken() // consume USER
-
-	userName, err := p.parseQuotedString()
-	if err != nil {
-		return nil, err
-	}
-	p.nextToken()
-
-	switch p.curToken.Type {
-	case TokenActivity:
-		return p.parseAdminShowActivityCommand(userName)
-	case TokenSummary:
-		return p.parseAdminShowUserSummaryCommand(userName)
-	case TokenDataset:
-		return p.parseAdminShowUserDataSetCommand(userName)
-	case TokenStorage:
-		return p.parseAdminShowUserStorageCommand(userName)
-	case TokenQuota:
-		return p.parseAdminShowUserQuotaCommand(userName)
-	case TokenIndex:
-		return p.parseAdminShowUserIndexCommand(userName)
-	case TokenPermission:
-		return p.parseAdminShowUserPermissionCommand(userName)
-	default:
-		return p.parseAdminShowUserInfoCommand(userName)
-	}
-}
-
-// SHOW USER 'user@example.com';
-func (p *Parser) parseAdminShowUserInfoCommand(userName string) (*Command, error) {
-
-	// Semicolon is optional
-	if p.curToken.Type == TokenSemicolon {
-		p.nextToken()
-	}
-
-	cmd := NewCommand("admin_show_user_info_command")
-	cmd.Params["user_name"] = userName
-
-	return cmd, nil
-}
-
-// SHOW USER 'user@example.com' ACTIVITY DAYS 30;
-func (p *Parser) parseAdminShowActivityCommand(userName string) (*Command, error) {
-	p.nextToken() // consume ACTIVITY
-
-	var days int
-	var err error
-
-	if p.curToken.Type == TokenDays {
-		p.nextToken() // consume DAYS
-		days, err = p.parseNumber()
-		if err != nil {
-			return nil, err
-		}
-		if days < 1 {
-			return nil, fmt.Errorf("invalid number of DAYS")
-		}
-		p.nextToken()
-	} else {
-		days = 7
-	}
-
-	// Semicolon is optional
-	if p.curToken.Type == TokenSemicolon {
-		p.nextToken()
-	}
-
-	cmd := NewCommand("admin_show_user_activity_command")
-	cmd.Params["user_name"] = userName
-	cmd.Params["days"] = days
-
-	return cmd, nil
-}
-
-// SHOW USER 'user@example.com' SUMMARY;
-func (p *Parser) parseAdminShowUserSummaryCommand(userName string) (*Command, error) {
-	p.nextToken() // consume SUMMARY
-
-	cmd := NewCommand("admin_show_user_summary_command")
-	cmd.Params["user_name"] = userName
-
-	// Semicolon is optional
-	if p.curToken.Type == TokenSemicolon {
-		p.nextToken()
-	}
-
-	return cmd, nil
-}
-
-// SHOW USER 'user@example.com' DATASET 'dataset_name';
-func (p *Parser) parseAdminShowUserDataSetCommand(userName string) (*Command, error) {
-	p.nextToken() // consume DATASET
-
-	var tree = false
-	var datasetName string
-	var err error
-	datasetName, err = p.parseQuotedString()
-	if err != nil {
-		return nil, err
-	}
-	p.nextToken()
-
-	if p.curToken.Type == TokenTree {
-		tree = true
-		p.nextToken()
-	}
-
-	cmd := NewCommand("admin_show_user_dataset_command")
-	cmd.Params["user_name"] = userName
-	if datasetName != "" {
-		cmd.Params["dataset_name"] = datasetName
-	}
-	if tree {
-		cmd.Params["tree"] = true
-	}
-
-	// Semicolon is optional
-	if p.curToken.Type == TokenSemicolon {
-		p.nextToken()
-	}
-
-	return cmd, nil
-}
-
-// SHOW USER 'user@example.com' STORAGE;
-func (p *Parser) parseAdminShowUserStorageCommand(userName string) (*Command, error) {
-	p.nextToken() // consume STORAGE
-
-	cmd := NewCommand("admin_show_user_storage_command")
-	cmd.Params["user_name"] = userName
-
-	// Semicolon is optional
-	if p.curToken.Type == TokenSemicolon {
-		p.nextToken()
-	}
-
-	return cmd, nil
-}
-
-// SHOW USER 'user@example.com' QUOTA;
-func (p *Parser) parseAdminShowUserQuotaCommand(userName string) (*Command, error) {
-	p.nextToken() // consume QUOTA
-
-	cmd := NewCommand("admin_show_user_quota_command")
-	cmd.Params["user_name"] = userName
-
-	// Semicolon is optional
-	if p.curToken.Type == TokenSemicolon {
-		p.nextToken()
-	}
-
-	return cmd, nil
-}
-
-// SHOW USER 'user@example.com' INDEX;
-func (p *Parser) parseAdminShowUserIndexCommand(userName string) (*Command, error) {
-	p.nextToken() // consume INDEX
-
-	cmd := NewCommand("admin_show_user_index_command")
-	cmd.Params["user_name"] = userName
-
-	// Semicolon is optional
-	if p.curToken.Type == TokenSemicolon {
-		p.nextToken()
-	}
-
-	return cmd, nil
-}
-
-// SHOW USER 'user@example.com' PERMISSION;
-func (p *Parser) parseAdminShowUserPermissionCommand(userName string) (*Command, error) {
-	p.nextToken() // consume PERMISSION
-
-	cmd := NewCommand("admin_show_user_permission_command")
-	cmd.Params["user_name"] = userName
-
-	// Semicolon is optional
-	if p.curToken.Type == TokenSemicolon {
-		p.nextToken()
-	}
-	return cmd, nil
-}
-
 // SHOW USERS SUMMARY;
 // SHOW USERS ACTIVITY;
 func (p *Parser) parseAdminShowUsersCommand() (*Command, error) {
@@ -2654,6 +2632,7 @@ commandLoop:
 }

 // LIST USER 'user@example.com' INGESTION TASKS;
+// LIST USER 'user_name' PROVIDER 'provider_name' INSTANCE 'instance_name' MODELS;
 func (p *Parser) parseAdminListUserCommand() (*Command, error) {
 	p.nextToken() // consume USER