Arcrun/registry/components/string_ops/main.go

// string_ops — 字串操作
// 支援: upper, lower, trim, capitalize, replace, split, join, includes,
//        starts_with, ends_with, length, substring
//
//go:build tinygo

package main

import (
	"encoding/json"
	"io"
	"os"
	"strings"
)

type Args struct {
	From   string   `json:"from"`
	To     string   `json:"to"`
	Sep    string   `json:"sep"`
	Items  []string `json:"items"`
	Substr string   `json:"substr"`
	Prefix string   `json:"prefix"`
	Suffix string   `json:"suffix"`
	Start  int      `json:"start"`
	End    int      `json:"end"`
}

type Input struct {
	Operation string `json:"operation"`
	Input     string `json:"input"`
	Args      Args   `json:"args"`
}

func main() {
	raw, err := io.ReadAll(os.Stdin)
	if err != nil {
		writeError("failed to read stdin: " + err.Error())
		return
	}
	var input Input
	if err := json.Unmarshal(raw, &input); err != nil {
		writeError("invalid input JSON: " + err.Error())
		return
	}
	if input.Operation == "" {
		writeError("operation 必填")
		return
	}

	var result interface{}

	switch input.Operation {
	case "upper":
		result = strings.ToUpper(input.Input)
	case "lower":
		result = strings.ToLower(input.Input)
	case "trim":
		result = strings.TrimSpace(input.Input)
	case "capitalize":
		if len(input.Input) == 0 {
			result = ""
		} else {
			result = strings.ToUpper(input.Input[:1]) + strings.ToLower(input.Input[1:])
		}
	case "replace":
		result = strings.ReplaceAll(input.Input, input.Args.From, input.Args.To)
	case "split":
		sep := input.Args.Sep
		if sep == "" {
			sep = ","
		}
		result = strings.Split(input.Input, sep)
	case "join":
		sep := input.Args.Sep
		result = strings.Join(input.Args.Items, sep)
	case "includes":
		result = strings.Contains(input.Input, input.Args.Substr)
	case "starts_with":
		result = strings.HasPrefix(input.Input, input.Args.Prefix)
	case "ends_with":
		result = strings.HasSuffix(input.Input, input.Args.Suffix)
	case "length":
		result = len([]rune(input.Input))
	case "substring":
		runes := []rune(input.Input)
		start := input.Args.Start
		end := input.Args.End
		if start < 0 {
			start = 0
		}
		if end <= 0 || end > len(runes) {
			end = len(runes)
		}
		if start > end {
			start = end
		}
		result = string(runes[start:end])
	default:
		writeError("不支援的 operation: " + input.Operation)
		return
	}

	out, _ := json.Marshal(map[string]interface{}{
		"success": true,
		"data": map[string]interface{}{
			"result":    result,
			"operation": input.Operation,
		},
	})
	os.Stdout.Write(out)
}

func writeError(msg string) {
	out, _ := json.Marshal(map[string]interface{}{"success": false, "error": msg})
	os.Stdout.Write(out)
}