fix(base): improve dashboard data diagnostics and slim lark-base skill

shortcuts/base/base_dashboard_execute_test.go

@@ -244,6 +244,32 @@ func TestBaseDashboardBlockExecuteGet(t *testing.T) {
 		}
 	})
 
+	t.Run("text block json readback diagnostics", func(t *testing.T) {
+		factory, stdout, reg := newExecuteFactory(t)
+		reg.Register(&httpmock.Stub{
+			Method: "GET",
+			URL:    "/open-apis/base/v3/bases/app_x/dashboards/dsh_001/blocks/blk_text",
+			Body: map[string]interface{}{
+				"code": 0,
+				"data": map[string]interface{}{
+					"block_id": "blk_text",
+					"name":     "文本",
+					"type":     "text",
+					"data_config": map[string]interface{}{
+						"text": "\"图表说明\"",
+					},
+				},
+			},
+		})
+		if err := runShortcut(t, BaseDashboardBlockGet, []string{"+dashboard-block-get", "--base-token", "app_x", "--dashboard-id", "dsh_001", "--block-id", "blk_text"}, factory, stdout); err != nil {
+			t.Fatalf("err=%v", err)
+		}
+		got := stdout.String()
+		if !strings.Contains(got, `"dashboard_text_json_readback"`) || !strings.Contains(got, `"text_plain": "图表说明"`) {
+			t.Fatalf("stdout=%s", got)
+		}
+	})
+
 	t.Run("with user-id-type", func(t *testing.T) {
 		factory, stdout, reg := newExecuteFactory(t)
 		reg.Register(&httpmock.Stub{
@@ -270,35 +296,70 @@ func TestBaseDashboardBlockExecuteGet(t *testing.T) {
 
 // TestBaseDashboardBlockExecuteGetData tests the +dashboard-block-get-data command.
 func TestBaseDashboardBlockExecuteGetData(t *testing.T) {
-	factory, stdout, reg := newExecuteFactory(t)
-	reg.Register(&httpmock.Stub{
-		Method: "GET",
-		URL:    "/open-apis/base/v3/bases/app_x/dashboards/blocks/blk_chart/data",
-		Body: map[string]interface{}{
-			"code": 0,
-			"data": map[string]interface{}{
-				"dimensions": []interface{}{
-					map[string]interface{}{"field_name": "文本", "alias": "dim_text"},
-				},
-				"measures": []interface{}{
-					map[string]interface{}{"field_name": "Bitable_Dashboard_Count", "aggregation": "count_all", "alias": "me_count"},
+	t.Run("with measure values", func(t *testing.T) {
+		factory, stdout, reg := newExecuteFactory(t)
+		reg.Register(&httpmock.Stub{
+			Method: "GET",
+			URL:    "/open-apis/base/v3/bases/app_x/dashboards/blocks/blk_chart/data",
+			Body: map[string]interface{}{
+				"code": 0,
+				"data": map[string]interface{}{
+					"dimensions": []interface{}{
+						map[string]interface{}{"field_name": "文本", "alias": "dim_text"},
+					},
+					"measures": []interface{}{
+						map[string]interface{}{"field_name": "Bitable_Dashboard_Count", "aggregation": "count_all", "alias": "me_count"},
+					},
+					"main_data": []interface{}{
+						map[string]interface{}{
+							"dim_text": map[string]interface{}{"value": "A"},
+							"me_count": map[string]interface{}{"value": 3},
+						},
+					},
 				},
-				"main_data": []interface{}{
-					map[string]interface{}{
-						"dim_text": map[string]interface{}{"value": "A"},
-						"me_count": map[string]interface{}{"value": 3},
+			},
+		})
+		if err := runShortcut(t, BaseDashboardBlockGetData, []string{"+dashboard-block-get-data", "--base-token", "app_x", "--block-id", "blk_chart"}, factory, stdout); err != nil {
+			t.Fatalf("err=%v", err)
+		}
+		got := stdout.String()
+		if !strings.Contains(got, `"dimensions"`) || !strings.Contains(got, `"main_data"`) || !strings.Contains(got, `"dim_text"`) {
+			t.Fatalf("stdout=%s", got)
+		}
+		if strings.Contains(got, `"_diagnostics"`) {
+			t.Fatalf("unexpected diagnostics in stdout=%s", got)
+		}
+	})
+
+	t.Run("diagnoses rows without measure values", func(t *testing.T) {
+		factory, stdout, reg := newExecuteFactory(t)
+		reg.Register(&httpmock.Stub{
+			Method: "GET",
+			URL:    "/open-apis/base/v3/bases/app_x/dashboards/blocks/blk_empty_measure/data",
+			Body: map[string]interface{}{
+				"code": 0,
+				"data": map[string]interface{}{
+					"dimensions": []interface{}{
+						map[string]interface{}{"field_name": "任务名称", "alias": "dim_task"},
+					},
+					"measures": []interface{}{
+						map[string]interface{}{"field_name": "处理时长", "aggregation": "sum", "alias": "me_duration"},
+					},
+					"main_data": []interface{}{
+						map[string]interface{}{"dim_task": map[string]interface{}{"value": "A"}},
+						map[string]interface{}{"dim_task": map[string]interface{}{"value": "B"}},
 					},
 				},
 			},
-		},
+		})
+		if err := runShortcut(t, BaseDashboardBlockGetData, []string{"+dashboard-block-get-data", "--base-token", "app_x", "--block-id", "blk_empty_measure"}, factory, stdout); err != nil {
+			t.Fatalf("err=%v", err)
+		}
+		got := stdout.String()
+		if !strings.Contains(got, `"_diagnostics"`) || !strings.Contains(got, `"empty_measure_values"`) || !strings.Contains(got, `"me_duration"`) {
+			t.Fatalf("stdout=%s", got)
+		}
 	})
-	if err := runShortcut(t, BaseDashboardBlockGetData, []string{"+dashboard-block-get-data", "--base-token", "app_x", "--block-id", "blk_chart"}, factory, stdout); err != nil {
-		t.Fatalf("err=%v", err)
-	}
-	got := stdout.String()
-	if !strings.Contains(got, `"dimensions"`) || !strings.Contains(got, `"main_data"`) || !strings.Contains(got, `"dim_text"`) {
-		t.Fatalf("stdout=%s", got)
-	}
 }
 
 // TestBaseDashboardBlockExecuteCreate tests the +dashboard-block-create command.
@@ -756,6 +817,38 @@ func TestBaseDashboardBlockExecuteUpdate_TextType(t *testing.T) {
 		if !strings.Contains(got, `"updated": true`) || !strings.Contains(got, "新内容") {
 			t.Fatalf("stdout=%s", got)
 		}
+		if strings.Contains(got, `"dashboard_text_json_readback"`) {
+			t.Fatalf("unexpected text diagnostics in stdout=%s", got)
+		}
+	})
+
+	t.Run("diagnoses json encoded text readback", func(t *testing.T) {
+		factory, stdout, reg := newExecuteFactory(t)
+		reg.Register(&httpmock.Stub{
+			Method: "PATCH",
+			URL:    "/open-apis/base/v3/bases/app_x/dashboards/dsh_001/blocks/blk_text",
+			Body: map[string]interface{}{
+				"code": 0,
+				"data": map[string]interface{}{
+					"block_id": "blk_text",
+					"name":     "文本",
+					"type":     "text",
+					"data_config": map[string]interface{}{
+						"text": "\"# 新内容\"",
+					},
+				},
+			},
+		})
+		args := []string{"+dashboard-block-update", "--base-token", "app_x", "--dashboard-id", "dsh_001", "--block-id", "blk_text",
+			"--data-config", `{"text":"# 新内容"}`,
+		}
+		if err := runShortcut(t, BaseDashboardBlockUpdate, args, factory, stdout); err != nil {
+			t.Fatalf("err=%v", err)
+		}
+		got := stdout.String()
+		if !strings.Contains(got, `"dashboard_text_json_readback"`) || !strings.Contains(got, `"text_plain": "# 新内容"`) {
+			t.Fatalf("stdout=%s", got)
+		}
 	})
 
 	t.Run("update without type skips strict validation", func(t *testing.T) {

shortcuts/base/base_execute_test.go

@@ -1277,6 +1277,29 @@ func TestBaseRecordExecuteReadCreateDelete(t *testing.T) {
 		}
 	})
 
+	t.Run("list json shorthand alias", func(t *testing.T) {
+		factory, stdout, reg := newExecuteFactory(t)
+		reg.Register(&httpmock.Stub{
+			Method: "GET",
+			URL:    "limit=1&offset=0",
+			Body: map[string]interface{}{
+				"code": 0,
+				"data": map[string]interface{}{
+					"fields":         []interface{}{"Name"},
+					"record_id_list": []interface{}{"rec_json_alias"},
+					"data":           []interface{}{[]interface{}{"Charlie"}},
+					"total":          1,
+				},
+			},
+		})
+		if err := runShortcut(t, BaseRecordList, []string{"+record-list", "--base-token", "app_x", "--table-id", "tbl_x", "--limit", "1", "--json"}, factory, stdout); err != nil {
+			t.Fatalf("err=%v", err)
+		}
+		if got := stdout.String(); !strings.Contains(got, `"record_id_list"`) || !strings.Contains(got, `"rec_json_alias"`) || strings.Contains(got, "| Name |") {
+			t.Fatalf("stdout=%s", got)
+		}
+	})
+
 	t.Run("list markdown format", func(t *testing.T) {
 		factory, stdout, reg := newExecuteFactory(t)
 		reg.Register(&httpmock.Stub{

shortcuts/base/base_shortcuts_test.go

@@ -461,6 +461,22 @@ func TestBaseLimitPageSizeAliasIsHidden(t *testing.T) {
 	}
 }
 
+func TestBaseRecordListJSONAliasIsHidden(t *testing.T) {
+	parent := &cobra.Command{Use: "base"}
+	BaseRecordList.Mount(parent, &cmdutil.Factory{})
+	cmd := parent.Commands()[0]
+	flag := cmd.Flags().Lookup("json")
+	if flag == nil {
+		t.Fatal("flag --json missing")
+	}
+	if !flag.Hidden {
+		t.Fatal("flag --json must be hidden")
+	}
+	if strings.Contains(cmd.Flags().FlagUsages(), "--json") {
+		t.Fatalf("help should not include hidden --json:\n%s", cmd.Flags().FlagUsages())
+	}
+}
+
 func TestBaseDashboardHelpGuidesAgents(t *testing.T) {
 	tests := []struct {
 		name     string

shortcuts/base/dashboard_ops.go

@@ -5,6 +5,7 @@ package base
 
 import (
 	"context"
+	"encoding/json"
 	"strings"
 
 	"github.com/larksuite/cli/shortcuts/common"
@@ -257,6 +258,7 @@ func executeDashboardBlockGet(runtime *common.RuntimeContext) error {
 	if err != nil {
 		return err
 	}
+	attachDashboardTextBlockDiagnostics(data)
 	runtime.Out(map[string]interface{}{"block": data}, nil)
 	return nil
 }
@@ -267,10 +269,80 @@ func executeDashboardBlockGetData(runtime *common.RuntimeContext) error {
 	if err != nil {
 		return err
 	}
+	attachDashboardBlockDataDiagnostics(data)
 	runtime.Out(data, nil)
 	return nil
 }
 
+func attachDashboardBlockDataDiagnostics(data map[string]interface{}) {
+	measureAliases := dashboardBlockMeasureAliases(data["measures"])
+	if len(measureAliases) == 0 {
+		return
+	}
+	rows, ok := data["main_data"].([]interface{})
+	if !ok || len(rows) == 0 {
+		return
+	}
+	for _, rawRow := range rows {
+		row, ok := rawRow.(map[string]interface{})
+		if !ok {
+			continue
+		}
+		if dashboardBlockRowHasMeasureValue(row, measureAliases) {
+			return
+		}
+	}
+	data["_diagnostics"] = []interface{}{
+		map[string]interface{}{
+			"type":            "empty_measure_values",
+			"message":         "chart data defines measures, but main_data rows contain no computed measure values",
+			"hint":            "Recreate or update the block data_config with a computable numeric measure or count_all, then rerun +dashboard-block-get-data before declaring the chart complete.",
+			"measure_aliases": measureAliases,
+			"main_data_rows":  len(rows),
+		},
+	}
+}
+
+func dashboardBlockMeasureAliases(raw interface{}) []string {
+	measures, ok := raw.([]interface{})
+	if !ok {
+		return nil
+	}
+	aliases := make([]string, 0, len(measures))
+	for _, rawMeasure := range measures {
+		measure, ok := rawMeasure.(map[string]interface{})
+		if !ok {
+			continue
+		}
+		alias, ok := measure["alias"].(string)
+		if !ok {
+			continue
+		}
+		alias = strings.TrimSpace(alias)
+		if alias != "" {
+			aliases = append(aliases, alias)
+		}
+	}
+	return aliases
+}
+
+func dashboardBlockRowHasMeasureValue(row map[string]interface{}, aliases []string) bool {
+	for _, alias := range aliases {
+		value, ok := row[alias]
+		if !ok || value == nil {
+			continue
+		}
+		valueMap, ok := value.(map[string]interface{})
+		if !ok {
+			return true
+		}
+		if nestedValue, exists := valueMap["value"]; exists && nestedValue != nil {
+			return true
+		}
+	}
+	return false
+}
+
 // executeDashboardBlockCreate creates a new dashboard block.
 func executeDashboardBlockCreate(runtime *common.RuntimeContext) error {
 	pc := newParseCtx(runtime)
@@ -325,10 +397,59 @@ func executeDashboardBlockUpdate(runtime *common.RuntimeContext) error {
 	if err != nil {
 		return err
 	}
+	attachDashboardTextBlockDiagnostics(data)
 	runtime.Out(map[string]interface{}{"block": data, "updated": true}, nil)
 	return nil
 }
 
+func attachDashboardTextBlockDiagnostics(block map[string]interface{}) {
+	if !isDashboardTextBlock(block) {
+		return
+	}
+	cfg, ok := block["data_config"].(map[string]interface{})
+	if !ok {
+		return
+	}
+	rawText, ok := cfg["text"].(string)
+	if !ok || strings.TrimSpace(rawText) == "" {
+		return
+	}
+	plainText, ok := decodeDashboardTextReadback(rawText)
+	if !ok || plainText == rawText {
+		return
+	}
+	appendDashboardDiagnostic(block, map[string]interface{}{
+		"type":       "dashboard_text_json_readback",
+		"message":    "text block data_config.text is returned as a JSON-encoded string",
+		"hint":       "When verifying text block content, compare text_plain with the target text; keep data_config.text unchanged for raw API compatibility.",
+		"text_plain": plainText,
+	})
+}
+
+func isDashboardTextBlock(block map[string]interface{}) bool {
+	blockType, _ := block["type"].(string)
+	if blockType == "" {
+		blockType, _ = block["block_type"].(string)
+	}
+	return strings.EqualFold(strings.TrimSpace(blockType), "text")
+}
+
+func decodeDashboardTextReadback(raw string) (string, bool) {
+	var decoded string
+	if err := json.Unmarshal([]byte(raw), &decoded); err != nil {
+		return "", false
+	}
+	return decoded, true
+}
+
+func appendDashboardDiagnostic(target map[string]interface{}, diagnostic map[string]interface{}) {
+	if existing, ok := target["_diagnostics"].([]interface{}); ok {
+		target["_diagnostics"] = append(existing, diagnostic)
+		return
+	}
+	target["_diagnostics"] = []interface{}{diagnostic}
+}
+
 // executeDashboardBlockDelete deletes a dashboard block by ID.
 func executeDashboardBlockDelete(runtime *common.RuntimeContext) error {
 	_, err := baseV3Call(runtime, "DELETE", baseV3Path("bases", runtime.Str("base-token"), "dashboards", runtime.Str("dashboard-id"), "blocks", runtime.Str("block-id")), nil, nil)

shortcuts/base/record_list.go

@@ -28,6 +28,7 @@ var BaseRecordList = common.Shortcut{
 		{Name: "limit", Type: "int", Default: "100", Desc: "pagination size, range 1-200"},
 		pageSizeLimitAliasFlag(),
 		recordReadFormatFlag(),
+		recordReadJSONOutputAliasFlag(),
 	},
 	Tips: []string{
 		"Example: lark-cli base +record-list --base-token <base_token> --table-id <table_id> --limit 50",
@@ -88,3 +89,7 @@ func recordReadFormatFlag() common.Flag {
 		Desc:    "output format: markdown (default) | json",
 	}
 }
+
+func recordReadJSONOutputAliasFlag() common.Flag {
+	return common.Flag{Name: "json", Type: "bool", Desc: "hidden shorthand for --format json", Hidden: true}
+}