feat: add language support and onboard configuration wizard (v0.2.0)

- Add language code intelligent parsing module (internal/lang)
- Support --lang parameter for target language specification
- Support multiple language code formats (BCP47, aliases, Chinese names)
- Implement interactive onboard configuration wizard
- Update Config struct with language fields
- Add survey library dependency for interactive UI
- Improve CLI command interface
- Add comprehensive unit tests for language module
- Update documentation (AGENTS.md, changelog.md, taolun.md, memory.md)

Supported language codes:
- Standard: zh-CN, zh-TW, en-US, en-GB, ja, ko, es, fr, de
- Aliases: cn, en, jp, kr, es, fr, de
- Chinese names: chinese, english, japanese

Commands:
- yoyo "Hello world" - basic translation
- yoyo --lang=cn "Hello world" - specify target language
- yoyo onboard - start configuration wizard
- yoyo onboard --force - force reconfiguration

Version: 0.2.0
This commit is contained in:
2026-03-29 01:30:42 +08:00
parent cd305a62ef
commit 24ba405d55
11 changed files with 1164 additions and 6 deletions

317
internal/lang/lang.go Normal file
View File

@@ -0,0 +1,317 @@
package lang
import (
"fmt"
"sort"
"strings"
)
// 语言代码映射表
var languageMap = map[string]string{
// 中文变体
"cn": "zh-CN",
"zh": "zh-CN", // 默认简体中文
"zhcn": "zh-CN",
"zhtw": "zh-TW",
"zhhk": "zh-HK",
"zh-hans": "zh-CN",
"zh-hant": "zh-TW",
"chinese": "zh-CN",
"简体中文": "zh-CN",
"繁体中文": "zh-TW",
// 英语变体
"en": "en-US", // 默认美式英语
"us": "en-US",
"uk": "en-GB",
"gb": "en-GB",
"english": "en-US",
"美式英语": "en-US",
"英式英语": "en-GB",
// 日语
"jp": "ja",
"ja": "ja",
"japanese": "ja",
"日语": "ja",
// 韩语
"kr": "ko",
"ko": "ko",
"korean": "ko",
"韩语": "ko",
// 西班牙语
"es": "es-ES",
"spanish": "es-ES",
"西班牙语": "es-ES",
// 法语
"fr": "fr-FR",
"french": "fr-FR",
"法语": "fr-FR",
// 德语
"de": "de-DE",
"german": "de-DE",
"德语": "de-DE",
// 俄语
"ru": "ru-RU",
"russian": "ru-RU",
"俄语": "ru-RU",
// 葡萄牙语
"pt": "pt-PT",
"portuguese": "pt-PT",
"葡萄牙语": "pt-PT",
"br": "pt-BR", // 巴西葡萄牙语
// 意大利语
"it": "it-IT",
"italian": "it-IT",
"意大利语": "it-IT",
// 阿拉伯语
"ar": "ar-SA",
"arabic": "ar-SA",
"阿拉伯语": "ar-SA",
// 印地语
"hi": "hi-IN",
"hindi": "hi-IN",
"印地语": "hi-IN",
// 其他语言
"nl": "nl-NL", // 荷兰语
"dutch": "nl-NL",
"sv": "sv-SE", // 瑞典语
"swedish": "sv-SE",
"no": "nb-NO", // 挪威语
"norwegian": "nb-NO",
"da": "da-DK", // 丹麦语
"danish": "da-DK",
"fi": "fi-FI", // 芬兰语
"finnish": "fi-FI",
"pl": "pl-PL", // 波兰语
"polish": "pl-PL",
"tr": "tr-TR", // 土耳其语
"turkish": "tr-TR",
"th": "th-TH", // 泰语
"thai": "th-TH",
"vi": "vi-VN", // 越南语
"vietnamese": "vi-VN",
"id": "id-ID", // 印尼语
"indonesian": "id-ID",
"ms": "ms-MY", // 马来语
"malay": "ms-MY",
}
// 语言名称到代码的映射(用于显示)
var languageNames = map[string]string{
"zh-CN": "中文(简体)",
"zh-TW": "中文(繁体)",
"zh-HK": "中文(香港)",
"en-US": "English (US)",
"en-GB": "English (UK)",
"ja": "日本語",
"ko": "한국어",
"es-ES": "Español",
"fr-FR": "Français",
"de-DE": "Deutsch",
"ru-RU": "Русский",
"pt-PT": "Português",
"pt-BR": "Português (Brasil)",
"it-IT": "Italiano",
"ar-SA": "العربية",
"hi-IN": "हिन्दी",
"nl-NL": "Nederlands",
"sv-SE": "Svenska",
"nb-NO": "Norsk",
"da-DK": "Dansk",
"fi-FI": "Suomi",
"pl-PL": "Polski",
"tr-TR": "Türkçe",
"th-TH": "ไทย",
"vi-VN": "Tiếng Việt",
"id-ID": "Bahasa Indonesia",
"ms-MY": "Bahasa Melayu",
}
// ParseLanguageCode 解析语言代码
// 支持多种格式标准BCP47格式、别名、中文名称等
func ParseLanguageCode(input string) string {
if input == "" {
return ""
}
// 转换为小写进行匹配
lower := strings.ToLower(strings.TrimSpace(input))
// 直接匹配
if code, exists := languageMap[lower]; exists {
return code
}
// 尝试解析BCP47格式如 zh-CN, en-US
if isValidLanguageTag(input) {
return normalizeLanguageTag(input)
}
// 如果无法解析,返回原始输入
return input
}
// isValidLanguageTag 检查是否是有效的语言标签格式
func isValidLanguageTag(tag string) bool {
// 简单的格式检查:语言代码-地区代码
parts := strings.Split(tag, "-")
if len(parts) == 1 {
// 只有语言代码,如 "zh", "en"
return len(parts[0]) >= 2 && len(parts[0]) <= 3
}
if len(parts) == 2 {
// 语言代码-地区代码,如 "zh-CN", "en-US"
return len(parts[0]) >= 2 && len(parts[0]) <= 3 && len(parts[1]) == 2
}
return false
}
// normalizeLanguageTag 标准化语言标签
func normalizeLanguageTag(tag string) string {
parts := strings.Split(tag, "-")
if len(parts) == 1 {
// 只有语言代码,使用默认地区
defaultRegions := map[string]string{
"zh": "CN",
"en": "US",
"ja": "JP",
"ko": "KR",
"es": "ES",
"fr": "FR",
"de": "DE",
"ru": "RU",
"pt": "PT",
"it": "IT",
"ar": "SA",
"hi": "IN",
"nl": "NL",
"sv": "SE",
"no": "NO",
"da": "DK",
"fi": "FI",
"pl": "PL",
"tr": "TR",
"th": "TH",
"vi": "VN",
"id": "ID",
"ms": "MY",
}
if region, exists := defaultRegions[parts[0]]; exists {
return fmt.Sprintf("%s-%s", strings.ToLower(parts[0]), strings.ToUpper(region))
}
return tag
}
if len(parts) == 2 {
// 标准化格式:语言小写,地区大写
return fmt.Sprintf("%s-%s", strings.ToLower(parts[0]), strings.ToUpper(parts[1]))
}
return tag
}
// GetLanguageName 获取语言名称(用于显示)
func GetLanguageName(code string) string {
if name, exists := languageNames[code]; exists {
return name
}
return code
}
// GetLanguageNameOrDefault 获取语言名称,如果不存在则返回代码
func GetLanguageNameOrDefault(code string, defaultName string) string {
if name, exists := languageNames[code]; exists {
return name
}
return defaultName
}
// SupportedLanguages 获取支持的语言列表
func SupportedLanguages() []string {
codes := make([]string, 0, len(languageNames))
for code := range languageNames {
codes = append(codes, code)
}
sort.Strings(codes)
return codes
}
// GetLanguageSuggestions 获取语言建议(用于模糊匹配)
func GetLanguageSuggestions(input string, limit int) []string {
if input == "" {
return []string{}
}
lower := strings.ToLower(input)
suggestions := make([]string, 0)
for alias, code := range languageMap {
if strings.Contains(alias, lower) || strings.Contains(strings.ToLower(code), lower) {
// 避免重复
found := false
for _, s := range suggestions {
if s == code {
found = true
break
}
}
if !found {
suggestions = append(suggestions, code)
}
}
}
// 限制数量
if len(suggestions) > limit {
suggestions = suggestions[:limit]
}
return suggestions
}
// IsLanguageSupported 检查语言是否支持
func IsLanguageSupported(code string) bool {
normalized := ParseLanguageCode(code)
_, exists := languageNames[normalized]
return exists
}
// GetCommonLanguages 获取常用语言列表
func GetCommonLanguages() []string {
return []string{
"zh-CN", // 中文(简体)
"en-US", // 英语(美国)
"ja", // 日语
"ko", // 韩语
"es-ES", // 西班牙语
"fr-FR", // 法语
"de-DE", // 德语
"ru-RU", // 俄语
"pt-PT", // 葡萄牙语
"it-IT", // 意大利语
}
}
// GetLanguageDirection 获取语言方向(从左到右或从右到左)
func GetLanguageDirection(code string) string {
rtlLanguages := map[string]bool{
"ar-SA": true, // 阿拉伯语
"he-IL": true, // 希伯来语
"fa-IR": true, // 波斯语
"ur-PK": true, // 乌尔都语
}
if rtlLanguages[code] {
return "rtl"
}
return "ltr"
}

224
internal/lang/lang_test.go Normal file
View File

@@ -0,0 +1,224 @@
package lang
import (
"testing"
)
func TestParseLanguageCode(t *testing.T) {
tests := []struct {
input string
expected string
}{
// 中文变体
{"cn", "zh-CN"},
{"zh", "zh-CN"},
{"zh-CN", "zh-CN"},
{"zh-TW", "zh-TW"},
{"zh-HK", "zh-HK"},
{"chinese", "zh-CN"},
{"简体中文", "zh-CN"},
// 英语变体
{"en", "en-US"},
{"en-US", "en-US"},
{"en-GB", "en-GB"},
{"us", "en-US"},
{"uk", "en-GB"},
{"english", "en-US"},
// 其他语言
{"jp", "ja"},
{"ja", "ja"},
{"japanese", "ja"},
{"kr", "ko"},
{"ko", "ko"},
{"korean", "ko"},
{"es", "es-ES"},
{"spanish", "es-ES"},
{"fr", "fr-FR"},
{"french", "fr-FR"},
{"de", "de-DE"},
{"german", "de-DE"},
// 空值
{"", ""},
// 未知语言(应返回原始输入)
{"unknown", "unknown"},
}
for _, tt := range tests {
t.Run(tt.input, func(t *testing.T) {
result := ParseLanguageCode(tt.input)
if result != tt.expected {
t.Errorf("ParseLanguageCode(%q) = %q, 期望 %q", tt.input, result, tt.expected)
}
})
}
}
func TestGetLanguageName(t *testing.T) {
tests := []struct {
code string
expected string
}{
{"zh-CN", "中文(简体)"},
{"zh-TW", "中文(繁体)"},
{"en-US", "English (US)"},
{"en-GB", "English (UK)"},
{"ja", "日本語"},
{"ko", "한국어"},
{"es-ES", "Español"},
{"fr-FR", "Français"},
{"de-DE", "Deutsch"},
{"unknown", "unknown"}, // 未知代码返回原值
}
for _, tt := range tests {
t.Run(tt.code, func(t *testing.T) {
result := GetLanguageName(tt.code)
if result != tt.expected {
t.Errorf("GetLanguageName(%q) = %q, 期望 %q", tt.code, result, tt.expected)
}
})
}
}
func TestSupportedLanguages(t *testing.T) {
languages := SupportedLanguages()
if len(languages) == 0 {
t.Error("SupportedLanguages() 不应返回空列表")
}
// 检查一些关键语言是否在列表中
expectedLanguages := []string{"zh-CN", "en-US", "ja", "ko"}
for _, expected := range expectedLanguages {
found := false
for _, lang := range languages {
if lang == expected {
found = true
break
}
}
if !found {
t.Errorf("Expected language %q not found in supported languages", expected)
}
}
}
func TestGetLanguageSuggestions(t *testing.T) {
tests := []struct {
input string
limit int
minCount int
}{
{"zh", 5, 1},
{"en", 5, 1},
{"chinese", 5, 1},
{"", 5, 0},
{"unknown", 5, 0},
}
for _, tt := range tests {
t.Run(tt.input, func(t *testing.T) {
suggestions := GetLanguageSuggestions(tt.input, tt.limit)
if len(suggestions) < tt.minCount {
t.Errorf("GetLanguageSuggestions(%q, %d) 返回 %d 个建议,至少需要 %d 个",
tt.input, tt.limit, len(suggestions), tt.minCount)
}
if len(suggestions) > tt.limit {
t.Errorf("GetLanguageSuggestions(%q, %d) 返回 %d 个建议,超过限制 %d 个",
tt.input, tt.limit, len(suggestions), tt.limit)
}
})
}
}
func TestIsLanguageSupported(t *testing.T) {
tests := []struct {
code string
expected bool
}{
{"zh-CN", true},
{"en-US", true},
{"ja", true},
{"unknown", false},
{"", false},
}
for _, tt := range tests {
t.Run(tt.code, func(t *testing.T) {
result := IsLanguageSupported(tt.code)
if result != tt.expected {
t.Errorf("IsLanguageSupported(%q) = %v, 期望 %v", tt.code, result, tt.expected)
}
})
}
}
func TestGetCommonLanguages(t *testing.T) {
languages := GetCommonLanguages()
if len(languages) == 0 {
t.Error("GetCommonLanguages() 不应返回空列表")
}
// 检查一些关键语言是否在列表中
expectedLanguages := []string{"zh-CN", "en-US", "ja"}
for _, expected := range expectedLanguages {
found := false
for _, lang := range languages {
if lang == expected {
found = true
break
}
}
if !found {
t.Errorf("Expected language %q not found in common languages", expected)
}
}
}
func TestGetLanguageDirection(t *testing.T) {
tests := []struct {
code string
expected string
}{
{"zh-CN", "ltr"},
{"en-US", "ltr"},
{"ja", "ltr"},
{"ar-SA", "rtl"},
{"he-IL", "rtl"},
}
for _, tt := range tests {
t.Run(tt.code, func(t *testing.T) {
result := GetLanguageDirection(tt.code)
if result != tt.expected {
t.Errorf("GetLanguageDirection(%q) = %q, 期望 %q", tt.code, result, tt.expected)
}
})
}
}
func TestNormalizeLanguageTag(t *testing.T) {
tests := []struct {
input string
expected string
}{
{"zh", "zh-CN"},
{"en", "en-US"},
{"ja", "ja-JP"},
{"zh-CN", "zh-CN"},
{"zh-tw", "zh-TW"},
{"EN-us", "en-US"},
}
for _, tt := range tests {
t.Run(tt.input, func(t *testing.T) {
result := normalizeLanguageTag(tt.input)
if result != tt.expected {
t.Errorf("normalizeLanguageTag(%q) = %q, 期望 %q", tt.input, result, tt.expected)
}
})
}
}