scriptorium/internal/adapter/cli/inspect.go

package cli

import (
	"context"
	"errors"
	"flag"
	"fmt"
	"io"
	"path/filepath"
	"strings"

	appconfig "gitea.maximumdirect.net/eric/scriptorium/internal/config"
	appformat "gitea.maximumdirect.net/eric/scriptorium/internal/format"
)

type promptInspectionConfig struct {
	configPath, promptDir, promptID, promptVersion, outputPath string
	outputFormat                                               appformat.OutputFormat
}

type profileInspectionConfig struct {
	configPath, profileDir, profileID, outputPath string
	outputFormat                                  appformat.OutputFormat
}

func inspectCommand(args []string, stdout, stderr io.Writer) int {
	if len(args) == 0 {
		fmt.Fprintln(stderr, "inspect parse error: inspection mode is required")
		return ExitRuntimeError
	}
	if args[0] == "profile" {
		return inspectProfileCommand(args[1:], stdout, stderr)
	}
	if args[0] != "prompt" {
		fmt.Fprintln(stderr, "inspect parse error: unknown inspection mode")
		return ExitRuntimeError
	}
	cfg, err := parsePromptInspectionArgs(args[1:])
	if err != nil {
		fmt.Fprintf(stderr, "inspect parse error: %v\n", err)
		return ExitRuntimeError
	}
	settings, err := resolveAppSettingsForPromptInspection(cfg)
	if err != nil {
		fmt.Fprintf(stderr, "inspect error: %v\n", err)
		return ExitRuntimeError
	}
	engine, err := newEngine(settings)
	if err != nil {
		fmt.Fprintf(stderr, "engine error: %v\n", err)
		return ExitRuntimeError
	}
	inspection, err := engine.InspectPrompt(context.Background(), cfg.promptID, cfg.promptVersion)
	if err != nil {
		fmt.Fprintf(stderr, "inspect error: %v\n", err)
		return ExitRuntimeError
	}
	data, err := appformat.FormatPromptInspection(inspection, cfg.outputFormat)
	if err != nil {
		fmt.Fprintf(stderr, "inspect error: %v\n", err)
		return ExitRuntimeError
	}
	if err := writeOutput(stdout, cfg.outputPath, data); err != nil {
		fmt.Fprintf(stderr, "output write error: %v\n", err)
		return ExitRuntimeError
	}
	return ExitOK
}

func inspectProfileCommand(args []string, stdout, stderr io.Writer) int {
	cfg, err := parseProfileInspectionArgs(args)
	if err != nil {
		fmt.Fprintf(stderr, "inspect parse error: %v\n", err)
		return ExitRuntimeError
	}
	settings, err := resolveAppSettingsForProfileInspection(cfg)
	if err != nil {
		fmt.Fprintf(stderr, "inspect error: %v\n", err)
		return ExitRuntimeError
	}
	engine, err := newEngine(settings)
	if err != nil {
		fmt.Fprintf(stderr, "engine error: %v\n", err)
		return ExitRuntimeError
	}
	inspection, err := engine.InspectProfile(context.Background(), cfg.profileID)
	if err != nil {
		fmt.Fprintf(stderr, "inspect error: %v\n", err)
		return ExitRuntimeError
	}
	data, err := appformat.FormatProfileInspection(inspection, cfg.outputFormat)
	if err != nil {
		fmt.Fprintf(stderr, "inspect error: %v\n", err)
		return ExitRuntimeError
	}
	if err := writeOutput(stdout, cfg.outputPath, data); err != nil {
		fmt.Fprintf(stderr, "output write error: %v\n", err)
		return ExitRuntimeError
	}
	return ExitOK
}

func parseProfileInspectionArgs(args []string) (*profileInspectionConfig, error) {
	cfg := &profileInspectionConfig{outputFormat: appformat.DefaultOutputFormat}
	fs := flag.NewFlagSet("inspect profile", flag.ContinueOnError)
	fs.SetOutput(io.Discard)
	registerConfigPathFlag(fs, &cfg.configPath)
	fs.StringVar(&cfg.profileDir, "profile-dir", "", "directory containing execution profiles")
	fs.StringVar(&cfg.profileID, "profile", "", "profile ID to inspect")
	rawFormat := ""
	fs.StringVar(&rawFormat, "format", "", "output format: text or json")
	fs.StringVar(&cfg.outputPath, "out", "", "optional output file path")
	if err := fs.Parse(args); err != nil {
		return nil, err
	}
	if fs.NArg() > 0 {
		return nil, fmt.Errorf("unexpected positional args: %v", fs.Args())
	}
	if strings.TrimSpace(cfg.profileID) == "" {
		return nil, errors.New("--profile is required")
	}
	format, err := appformat.ParseOutputFormat(rawFormat)
	if err != nil {
		return nil, err
	}
	cfg.outputFormat = format
	if cfg.outputPath != "" {
		cfg.outputPath = filepath.Clean(cfg.outputPath)
	}
	return cfg, nil
}

func resolveAppSettingsForProfileInspection(cfg *profileInspectionConfig) (engineSettings, error) {
	settings, err := appconfig.LoadConfig(cfg.configPath, cfg.configPath != "")
	if err != nil {
		return engineSettings{}, fmt.Errorf("application config error: %w", err)
	}
	if strings.TrimSpace(cfg.profileDir) != "" {
		settings.ProfileDir = filepath.Clean(cfg.profileDir)
	}
	return engineSettings{promptDir: ".", profileDir: settings.ProfileDir, backends: settings.Backends}, nil
}

func parsePromptInspectionArgs(args []string) (*promptInspectionConfig, error) {
	cfg := &promptInspectionConfig{outputFormat: appformat.DefaultOutputFormat}
	fs := flag.NewFlagSet("inspect prompt", flag.ContinueOnError)
	fs.SetOutput(io.Discard)
	registerConfigPathFlag(fs, &cfg.configPath)
	fs.StringVar(&cfg.promptDir, "prompt-dir", "", "directory containing prompt definitions")
	fs.StringVar(&cfg.promptID, "prompt", "", "prompt ID to inspect")
	fs.StringVar(&cfg.promptVersion, "prompt-version", "", "optional prompt version")
	rawFormat := ""
	fs.StringVar(&rawFormat, "format", "", "output format: text or json")
	fs.StringVar(&cfg.outputPath, "out", "", "optional output file path")
	if err := fs.Parse(args); err != nil {
		return nil, err
	}
	if fs.NArg() > 0 {
		return nil, fmt.Errorf("unexpected positional args: %v", fs.Args())
	}
	if strings.TrimSpace(cfg.promptID) == "" {
		return nil, errors.New("--prompt is required")
	}
	format, err := appformat.ParseOutputFormat(rawFormat)
	if err != nil {
		return nil, err
	}
	cfg.outputFormat = format
	if cfg.outputPath != "" {
		cfg.outputPath = filepath.Clean(cfg.outputPath)
	}
	return cfg, nil
}

func resolveAppSettingsForPromptInspection(cfg *promptInspectionConfig) (engineSettings, error) {
	settings, err := appconfig.LoadConfig(cfg.configPath, cfg.configPath != "")
	if err != nil {
		return engineSettings{}, fmt.Errorf("application config error: %w", err)
	}
	if strings.TrimSpace(cfg.promptDir) != "" {
		settings.PromptDir = filepath.Clean(cfg.promptDir)
	}
	if strings.TrimSpace(settings.PromptDir) == "" {
		return engineSettings{}, errors.New(errPromptDirRequired)
	}
	return engineSettings{promptDir: settings.PromptDir, backends: settings.Backends}, nil
}