cli.go

// SPDX-License-Identifier: MIT

package executor

import (
	"context"
	"fmt"
	"os/exec"
	"strings"
	"time"

	"github.com/ankit373/hydra/internal/sandbox"
	"github.com/ankit373/hydra/internal/util"
)

// CLIExecutor runs a prompt via a subprocess CLI tool.
type CLIExecutor struct{}

func (e *CLIExecutor) Execute(ctx context.Context, req Request) (*Response, error) {
	tmpl, ok := cliTemplates[req.Head.Provider]
	if !ok {
		tmpl, ok = cliTemplates[req.Head.ID]
	}
	if !ok {
		return nil, fmt.Errorf("no CLI template for head %q (provider %q)", req.Head.ID, req.Head.Provider)
	}

	args := tmpl.buildArgs(req.Prompt)
	cmd := sandbox.Harden(exec.CommandContext(ctx, req.Head.Executable, args...))
	env, closeGate, err := gateIfLocalOnly(ctx, req.Head, headEnv(req.Head))
	if err != nil {
		return nil, err
	}
	defer closeGate()
	cmd.Env = env
	if err := sandbox.WithLimits(cmd, req.MaxMemoryMB, req.MaxCPUSeconds); err != nil {
		return nil, err
	}

	if tmpl.stdinPrompt {
		cmd.Stdin = strings.NewReader(req.Prompt)
	}

	stdout := util.NewAccumulator(0)
	stderr := util.NewAccumulator(64 << 10)
	cmd.Stdout = stdout
	cmd.Stderr = stderr

	start := time.Now()
	if err := cmd.Run(); err != nil {
		return nil, fmt.Errorf("cli exec %s: %w, stderr: %s", req.Head.ID, err, stderr.String())
	}

	output := strings.TrimSpace(stdout.String())

	promptTokens := EstimateTokens(req.Prompt)
	responseTokens := EstimateTokens(output)
	writeTokenSidecar(req.Head.ID, "cli", "estimate", promptTokens, responseTokens)

	return &Response{
		Output:       output,
		Duration:     measured(time.Since(start)),
		Model:        req.Head.ID,
		InputTokens:  promptTokens,
		OutputTokens: responseTokens,
		Truncated:    stdout.Truncated(),
		// CLI tools (claude, codex, cursor, ...) report no token usage, these
		// are char/4 estimates, same heuristic as the agy executor.
		TokensEstimated: true,
	}, nil
}

// cliTemplate describes how to invoke a specific AI CLI tool.
type cliTemplate struct {
	args        []string // positional args before the prompt; use "" as prompt placeholder
	stdinPrompt bool     // if true, prompt is passed via stdin instead of args
}

func (t cliTemplate) buildArgs(prompt string) []string {
	var out []string
	for _, a := range t.args {
		if a == "" {
			out = append(out, prompt)
		} else {
			out = append(out, a)
		}
	}
	return out
}

// cliTemplates maps provider ID (or head ID) to invocation template.
// To add a new CLI tool, add an entry here and in capabilities/data.json.
var cliTemplates = map[string]cliTemplate{
	"anthropic":   {args: []string{"--print", ""}}, // claude --print "<prompt>"
	"openai":      {args: []string{"exec", ""}},    // codex exec "<prompt>", bare codex launches its interactive TUI (#491)
	"google":      {args: []string{""}},            // gemini "<prompt>"
	"antigravity": {args: []string{"--print", ""}}, // agy --print "<prompt>", bare agy launches its interactive TUI and, unlike codex, still exits 0 (#492)
	"cursor":      {args: []string{"--stdio"}, stdinPrompt: true},
	"amazon":      {args: []string{""}},                       // kiro "<prompt>"
	"codeium":     {args: []string{""}},                       // windsurf "<prompt>"
	"github":      {args: []string{"copilot", "suggest", ""}}, // gh-copilot
	"sourcegraph": {args: []string{"ask", ""}},                // cody ask "<prompt>"
	"continue":    {stdinPrompt: true},
	"amp":         {args: []string{""}},
}