feat: add native Kimi hook integration

cmd/elydora/plugins/kimi_io.go

@@ -0,0 +1,156 @@
+package plugins
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"syscall"
+)
+
+func kimiHomeDirectory() (string, error) {
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return "", fmt.Errorf("resolve home directory: %w", err)
+	}
+	return home, nil
+}
+
+func isMissingKimiPath(err error) bool {
+	return os.IsNotExist(err) || errors.Is(err, syscall.ENOTDIR)
+}
+
+func kimiPathExists(path, label string) (bool, error) {
+	// #nosec G703 -- KIMI_CODE_HOME is an explicit local-user configuration path.
+	_, err := os.Stat(path)
+	if err == nil {
+		return true, nil
+	}
+	if isMissingKimiPath(err) {
+		return false, nil
+	}
+	return false, fmt.Errorf("inspect %s at %s: %w", label, path, err)
+}
+
+func legacyKimiCLIOnPath() (bool, error) {
+	_, err := exec.LookPath("kimi-cli")
+	if err == nil {
+		return true, nil
+	}
+	if errors.Is(err, exec.ErrNotFound) {
+		return false, nil
+	}
+	return false, fmt.Errorf("inspect kimi-cli executable on PATH: %w", err)
+}
+
+func resolveKimiContracts() ([]kimiContract, error) {
+	home, err := kimiHomeDirectory()
+	if err != nil {
+		return nil, err
+	}
+	explicitHome := os.Getenv("KIMI_CODE_HOME")
+	kimiHome := explicitHome
+	if kimiHome == "" {
+		kimiHome = filepath.Join(home, ".kimi-code")
+	}
+	modern := kimiContract{
+		runtimeName: "Kimi Code",
+		label:       "Kimi Code hooks config",
+		configPath:  filepath.Join(kimiHome, "config.toml"),
+		events:      kimiModernEvents,
+	}
+	legacy := kimiContract{
+		runtimeName: "kimi-cli",
+		label:       "kimi-cli legacy hooks config",
+		configPath:  filepath.Join(home, ".kimi", "config.toml"),
+		events:      kimiSharedEvents,
+	}
+	modernDetected := explicitHome != ""
+	if !modernDetected {
+		modernDetected, err = kimiPathExists(kimiHome, "Kimi Code home")
+		if err != nil {
+			return nil, err
+		}
+	}
+	legacyDetected, err := kimiPathExists(legacy.configPath, legacy.label)
+	if err != nil {
+		return nil, err
+	}
+	if !legacyDetected {
+		legacyDetected, err = legacyKimiCLIOnPath()
+		if err != nil {
+			return nil, err
+		}
+	}
+	if legacyDetected && !modernDetected {
+		return []kimiContract{legacy}, nil
+	}
+	if legacyDetected {
+		return []kimiContract{modern, legacy}, nil
+	}
+	return []kimiContract{modern}, nil
+}
+
+func readKimiConfig(contract kimiContract) (kimiDocument, error) {
+	raw, err := os.ReadFile(contract.configPath)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return parseKimiDocument(contract, nil, false)
+		}
+		return kimiDocument{}, fmt.Errorf("read %s at %s: %w", contract.label, contract.configPath, err)
+	}
+	return parseKimiDocument(contract, raw, true)
+}
+
+func readAllKimiConfigs() ([]kimiDocument, error) {
+	contracts, err := resolveKimiContracts()
+	if err != nil {
+		return nil, err
+	}
+	documents := make([]kimiDocument, 0, len(contracts))
+	for _, contract := range contracts {
+		document, err := readKimiConfig(contract)
+		if err != nil {
+			return nil, err
+		}
+		documents = append(documents, document)
+	}
+	return documents, nil
+}
+
+func writeKimiConfig(document kimiDocument, raw []byte) error {
+	if err := writeHookFileAtomic(document.contract.configPath, raw, 0600); err != nil {
+		return fmt.Errorf("write %s at %s: %w", document.contract.label, document.contract.configPath, err)
+	}
+	return nil
+}
+
+func removeKimiConfig(document kimiDocument) error {
+	if err := removeHookFile(document.contract.configPath, document.contract.label); err != nil {
+		return err
+	}
+	return nil
+}
+
+func buildKimiCommand(runtimePath, scriptPath string) string {
+	if runtime.GOOS == "windows" {
+		return quoteWindowsArgument(runtimePath) + " " + quoteWindowsArgument(scriptPath)
+	}
+	return quotePOSIXArgument(runtimePath) + " " + quotePOSIXArgument(scriptPath)
+}
+
+func buildKimiHook(event, command string) kimiHook {
+	timeout := kimiHookTimeoutSeconds
+	return kimiHook{event: event, command: command, timeout: &timeout}
+}
+
+func kimiRuntimeNames(documents []kimiDocument) string {
+	names := make([]string, 0, len(documents))
+	for _, document := range documents {
+		names = append(names, document.contract.runtimeName)
+	}
+	return strings.Join(names, " and ")
+}