Add tool pkg

2026-09-25 13:45:15 +00:00
parent 7224fea99f
commit 7ac72cef6a
2 changed files with 952 additions and 0 deletions
@@ -0,0 +1,543 @@
+package tool
+
+import (
+	"bytes"
+	"context"
+	"os/exec"
+	"strings"
+	"testing"
+	"time"
+
+	"code.chimeric.al/chimerical/odidere/internal/config"
+)
+
+func TestTool_ParseArguments(t *testing.T) {
+	tool, err := NewTool(config.ToolConfig{
+		Arguments: []string{"--name {{.name}}", "{{if .flag}}--enabled{{end}}"},
+	})
+	if err != nil {
+		t.Fatalf("NewTool() error = %v", err)
+	}
+	tests := []struct {
+		name        string
+		args        string
+		expected    []string
+		wantErr     bool
+		errContains string
+	}{
+		{
+			name:     "basic",
+			args:     `{"name": "test"}`,
+			expected: []string{"--name test"},
+		},
+		{
+			// Documented limitation (see the ParseArguments doc): numbers
+			// decode as float64, so integers past 2^53 render in
+			// floating-point form.
+			name:     "large integer (float64 limitation)",
+			args:     `{"name": 9007199254740993}`,
+			expected: []string{"--name 9.007199254740992e+15"},
+		},
+		{
+			name:     "with flag",
+			args:     `{"name": "test", "flag": true}`,
+			expected: []string{"--name test", "--enabled"},
+		},
+		{
+			name:     "null",
+			args:     "null",
+			expected: []string{"--name <no value>"},
+		},
+		{
+			name:        "invalid JSON",
+			args:        `{invalid`,
+			wantErr:     true,
+			errContains: "invalid arguments JSON",
+		},
+		{
+			name:        "non-object JSON",
+			args:        `[1, 2, 3]`,
+			wantErr:     true,
+			errContains: "invalid arguments JSON",
+		},
+		{
+			name:        "trailing data",
+			args:        `{"name": "x"} trailing`,
+			wantErr:     true,
+			errContains: "invalid arguments JSON",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := tool.ParseArguments(tt.args)
+			if (err != nil) != tt.wantErr {
+				t.Fatalf("ParseArguments() error = %v, wantErr %v", err, tt.wantErr)
+			}
+			if tt.wantErr {
+				if !strings.Contains(err.Error(), tt.errContains) {
+					t.Errorf("err = %q, want to contain %q", err, tt.errContains)
+				}
+				return
+			}
+			if len(got) != len(tt.expected) {
+				t.Fatalf("expected len %d, got %d", len(tt.expected), len(got))
+			}
+			for i := range got {
+				if got[i] != tt.expected[i] {
+					t.Errorf("expected %q, got %q", tt.expected[i], got[i])
+				}
+			}
+		})
+	}
+}
+
+func TestTool_ParseArguments_ExecutionError(t *testing.T) {
+	// "{{printf}}" parses cleanly but fails at execution: printf
+	// requires at least one argument.
+	tool, err := NewTool(config.ToolConfig{
+		Arguments: []string{"{{printf}}"},
+	})
+	if err != nil {
+		t.Fatalf("NewTool() error = %v", err)
+	}
+	_, err = tool.ParseArguments(`{}`)
+	if err == nil {
+		t.Fatal("ParseArguments() error = nil, want execution error")
+	}
+	if !strings.Contains(err.Error(), "execute template") {
+		t.Errorf("err = %v, want execute template error", err)
+	}
+}
+
+func TestNewTool(t *testing.T) {
+	tool, err := NewTool(config.ToolConfig{
+		Name:        "test",
+		Description: "desc",
+		Command:     "ls",
+		Timeout:     10 * time.Second,
+	})
+	if err != nil {
+		t.Fatalf("NewTool() error = %v", err)
+	}
+	if tool.Name != "test" {
+		t.Errorf("Name = %q, want %q", tool.Name, "test")
+	}
+	if tool.timeout != 10*time.Second {
+		t.Errorf("timeout = %v, want 10s", tool.timeout)
+	}
+}
+
+func TestNewTool_InvalidTemplate(t *testing.T) {
+	tests := []struct {
+		name string
+		arg  string
+	}{
+		{name: "unclosed action", arg: "{{.name"},
+		{name: "undefined function", arg: "{{nosuch .name}}"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			_, err := NewTool(config.ToolConfig{
+				Name: "t", Arguments: []string{tt.arg},
+			})
+			if err == nil {
+				t.Fatal("NewTool() error = nil, want template error")
+			}
+			if !strings.Contains(err.Error(), "invalid template") {
+				t.Errorf("err = %v, want invalid template error", err)
+			}
+		})
+	}
+}
+
+func TestRegistry_NewRegistry(t *testing.T) {
+	tests := []struct {
+		name    string
+		tools   []config.ToolConfig
+		wantErr bool
+	}{
+		{
+			name: "valid",
+			tools: []config.ToolConfig{
+				{Name: "t1", Description: "d1", Command: "c1"},
+				{Name: "t2", Description: "d2", Command: "c2"},
+			},
+			wantErr: false,
+		},
+		{
+			name: "duplicate",
+			tools: []config.ToolConfig{
+				{Name: "t1", Description: "d1", Command: "c1"},
+				{Name: "t1", Description: "d2", Command: "c2"},
+			},
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			_, err := NewRegistry(tt.tools)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("NewRegistry() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestRegistry_ToAPI_Nil(t *testing.T) {
+	var reg *Registry
+	got := reg.ToAPI()
+	if got != nil {
+		t.Errorf("Registry.ToAPI(nil) = %v, want nil", got)
+	}
+}
+
+func TestRegistry_ToAPI_Empty(t *testing.T) {
+	reg, err := NewRegistry(nil)
+	if err != nil {
+		t.Fatalf("NewRegistry(nil) error = %v", err)
+	}
+	got := reg.ToAPI()
+	if len(got) != 0 {
+		t.Errorf("Registry.ToAPI(empty) len = %d, want 0", len(got))
+	}
+}
+
+func TestRegistry_ToAPI_Single(t *testing.T) {
+	reg, err := NewRegistry([]config.ToolConfig{
+		{
+			Name:        "weather",
+			Description: "Get the weather",
+			Parameters:  map[string]any{"type": "object"},
+		},
+	})
+	if err != nil {
+		t.Fatalf("NewRegistry error = %v", err)
+	}
+	got := reg.ToAPI()
+	if len(got) != 1 {
+		t.Fatalf("len = %d, want 1", len(got))
+	}
+	if got[0].Type != "function" {
+		t.Errorf("type = %q, want %q", got[0].Type, "function")
+	}
+	if got[0].Function.Name != "weather" {
+		t.Errorf("name = %q, want %q", got[0].Function.Name, "weather")
+	}
+	if got[0].Function.Description != "Get the weather" {
+		t.Errorf("description = %q, want %q", got[0].Function.Description, "Get the weather")
+	}
+}
+
+func TestTool_ToAPI(t *testing.T) {
+	tool := &Tool{
+		Name:        "test",
+		Description: "A test tool",
+		Parameters:  map[string]any{"type": "object"},
+		Command:     "echo",
+		Arguments:   []string{"hello"},
+	}
+
+	api := tool.ToAPI()
+	if api.Type != "function" {
+		t.Errorf("type = %q, want %q", api.Type, "function")
+	}
+	if api.Function.Name != "test" {
+		t.Errorf("name = %q, want %q", api.Function.Name, "test")
+	}
+	if api.Function.Description != "A test tool" {
+		t.Errorf("description = %q, want %q", api.Function.Description, "A test tool")
+	}
+	if api.Function.Parameters == nil {
+		t.Error("parameters is nil")
+	}
+}
+
+func TestToolResult_FormatResult(t *testing.T) {
+	// Get real ProcessState values from actual commands.
+	cmdOK := exec.Command("sh", "-c", "exit 0")
+	if err := cmdOK.Run(); err != nil {
+		t.Fatalf("cmdOK: %v", err)
+	}
+	cmdFail := exec.Command("sh", "-c", "exit 3")
+	cmdFail.Run() // expect non-nil error
+	cmdKill := exec.Command("sh", "-c", "kill -9 $$")
+	cmdKill.Run() // expect non-nil error
+
+	// Fixed times, so the rendered timing lines are deterministic.
+	started := time.Date(2026, 9, 23, 20, 31, 0, 123_000_000, time.UTC)
+	finished := started.Add(1500 * time.Millisecond)
+
+	// Every case renders the same timing lines, because every case uses
+	// the same times.
+	wantStart := "┗ start: " + started.Format(time.RFC3339Nano)
+	wantEnd := "┗ end: " + finished.Format(time.RFC3339Nano)
+	wantDuration := "┗ duration: 1.5s"
+
+	tests := []struct {
+		name         string
+		result       ToolResult
+		wantContains []string
+	}{
+		{
+			name: "success with stdout",
+			result: ToolResult{
+				FinishedAt:   finished,
+				ProcessState: cmdOK.ProcessState,
+				StartedAt:    started,
+				Stdout:       []byte("hello\n"),
+			},
+			wantContains: []string{
+				"▸ stdout:", "hello", "▸ stderr:", "┗ exit: 0",
+				wantStart, wantEnd, wantDuration,
+			},
+		},
+		{
+			name: "failure with stderr",
+			result: ToolResult{
+				FinishedAt:   finished,
+				ProcessState: cmdFail.ProcessState,
+				StartedAt:    started,
+				Stderr:       []byte("error occurred\n"),
+			},
+			wantContains: []string{
+				"▸ stdout:", "▸ stderr:", "error occurred", "┗ exit: 3",
+				wantStart, wantEnd, wantDuration,
+			},
+		},
+		{
+			name: "both stdout and stderr",
+			result: ToolResult{
+				FinishedAt:   finished,
+				ProcessState: cmdOK.ProcessState,
+				StartedAt:    started,
+				Stderr:       []byte("warning"),
+				Stdout:       []byte("output"),
+			},
+			wantContains: []string{
+				"▸ stdout:", "output", "▸ stderr:", "warning", "┗ exit: 0",
+				wantStart, wantEnd, wantDuration,
+			},
+		},
+		{
+			name: "empty output",
+			result: ToolResult{
+				FinishedAt:   finished,
+				ProcessState: cmdOK.ProcessState,
+				StartedAt:    started,
+			},
+			wantContains: []string{
+				"▸ stdout:", "▸ stderr:", "┗ exit: 0",
+				wantStart, wantEnd, wantDuration,
+			},
+		},
+		{
+			name: "binary stdout (PNG)",
+			result: ToolResult{
+				FinishedAt:   finished,
+				ProcessState: cmdOK.ProcessState,
+				StartedAt:    started,
+				Stdout:       []byte("\x89PNG\r\n\x1a\n"),
+			},
+			wantContains: []string{
+				"▸ stdout:", binaryOutputPrefix, "image/png", "▸ stderr:",
+				"┗ exit: 0", wantStart, wantEnd, wantDuration,
+			},
+		},
+		{
+			name: "binary stderr",
+			result: ToolResult{
+				FinishedAt:   finished,
+				ProcessState: cmdOK.ProcessState,
+				StartedAt:    started,
+				Stderr:       []byte("\x89PNG\r\n\x1a\n"),
+			},
+			wantContains: []string{
+				"▸ stdout:", "▸ stderr:", binaryOutputPrefix, "image/png",
+				"┗ exit: 0", wantStart, wantEnd, wantDuration,
+			},
+		},
+		{
+			name: "HTML",
+			result: ToolResult{
+				FinishedAt:   finished,
+				ProcessState: cmdOK.ProcessState,
+				StartedAt:    started,
+				Stdout:       []byte("<HTML><BODY>Hello</BODY></HTML>\n"),
+			},
+			wantContains: []string{
+				"▸ stdout:", "<HTML>", "▸ stderr:", "┗ exit: 0",
+				wantStart, wantEnd, wantDuration,
+			},
+		},
+		{
+			name: "XML",
+			result: ToolResult{
+				FinishedAt:   finished,
+				ProcessState: cmdOK.ProcessState,
+				StartedAt:    started,
+				Stdout:       []byte("<?xml version=\"1.0\"?><root/>\n"),
+			},
+			wantContains: []string{
+				"▸ stdout:", "<?xml", "▸ stderr:", "┗ exit: 0",
+				wantStart, wantEnd, wantDuration,
+			},
+		},
+		{
+			name: "Go source",
+			result: ToolResult{
+				FinishedAt:   finished,
+				ProcessState: cmdOK.ProcessState,
+				StartedAt:    started,
+				Stdout:       []byte("package main\n\nfunc main() {}\n"),
+			},
+			wantContains: []string{
+				"▸ stdout:", "package main", "▸ stderr:", "┗ exit: 0",
+				wantStart, wantEnd, wantDuration,
+			},
+		},
+		{
+			name: "JSON",
+			result: ToolResult{
+				FinishedAt:   finished,
+				ProcessState: cmdOK.ProcessState,
+				StartedAt:    started,
+				Stdout:       []byte(`{"key":"value"}`),
+			},
+			wantContains: []string{
+				"▸ stdout:", `{"key":"value"}`, "▸ stderr:", "┗ exit: 0",
+				wantStart, wantEnd, wantDuration,
+			},
+		},
+		{
+			name: "killed by signal",
+			result: ToolResult{
+				FinishedAt:   finished,
+				ProcessState: cmdKill.ProcessState,
+				StartedAt:    started,
+			},
+			wantContains: []string{
+				"▸ stdout:", "▸ stderr:", "┗ exit: -1 (signal: killed)",
+				wantStart, wantEnd, wantDuration,
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := tt.result.FormatResult()
+			for _, want := range tt.wantContains {
+				if !strings.Contains(got, want) {
+					t.Errorf("FormatResult() = %q, want to contain %q", got, want)
+				}
+			}
+		})
+	}
+}
+
+func TestRegistry_Execute_Success(t *testing.T) {
+	reg, err := NewRegistry([]config.ToolConfig{
+		{Name: "echo", Description: "echo", Command: "echo", Arguments: []string{"hello"}},
+	})
+	if err != nil {
+		t.Fatalf("NewRegistry: %v", err)
+	}
+
+	result, err := reg.Execute(context.Background(), "echo", "{}")
+	if err != nil {
+		t.Fatalf("Execute: %v", err)
+	}
+	if result.ProcessState.ExitCode() != 0 {
+		t.Errorf("ExitCode = %d, want 0", result.ProcessState.ExitCode())
+	}
+	if !bytes.Contains(result.Stdout, []byte("hello")) {
+		t.Errorf("Stdout = %q, want to contain hello", result.Stdout)
+	}
+}
+
+func TestRegistry_Execute_NonZeroExit(t *testing.T) {
+	reg, err := NewRegistry([]config.ToolConfig{
+		{Name: "fail", Description: "fail", Command: "sh", Arguments: []string{"-c", "exit 42"}},
+	})
+	if err != nil {
+		t.Fatalf("NewRegistry: %v", err)
+	}
+
+	result, err := reg.Execute(context.Background(), "fail", "{}")
+	if err != nil {
+		t.Fatalf("Execute: %v", err)
+	}
+	if result.ProcessState.ExitCode() != 42 {
+		t.Errorf("ExitCode = %d, want 42", result.ProcessState.ExitCode())
+	}
+}
+
+func TestRegistry_Execute_UnknownCommand(t *testing.T) {
+	reg, err := NewRegistry([]config.ToolConfig{
+		{Name: "nope", Description: "nope", Command: "nonexistent_binary_xyz", Arguments: []string{}},
+	})
+	if err != nil {
+		t.Fatalf("NewRegistry: %v", err)
+	}
+
+	_, err = reg.Execute(context.Background(), "nope", "{}")
+	if err == nil {
+		t.Fatal("Execute: want error, got nil")
+	}
+}
+
+func TestRegistry_Execute_UnknownTool(t *testing.T) {
+	reg, err := NewRegistry([]config.ToolConfig{})
+	if err != nil {
+		t.Fatalf("NewRegistry: %v", err)
+	}
+
+	_, err = reg.Execute(context.Background(), "missing", "{}")
+	if err == nil {
+		t.Fatal("Execute: want error, got nil")
+	}
+	if !strings.Contains(err.Error(), "unknown tool") {
+		t.Errorf("err = %v, want unknown tool error", err)
+	}
+}
+
+func TestRegistry_Execute_Timeout(t *testing.T) {
+	reg, err := NewRegistry([]config.ToolConfig{
+		{Name: "sleep", Description: "sleep", Command: "sleep", Arguments: []string{"10"}, Timeout: 50 * time.Millisecond},
+	})
+	if err != nil {
+		t.Fatalf("NewRegistry: %v", err)
+	}
+
+	_, err = reg.Execute(context.Background(), "sleep", "{}")
+	if err == nil {
+		t.Fatal("Execute: want timeout error, got nil")
+	}
+	if !strings.Contains(err.Error(), "timed out") {
+		t.Errorf("err = %v, want timed out error", err)
+	}
+}
+
+func TestRegistry_Execute_SignalKilled(t *testing.T) {
+	reg, err := NewRegistry([]config.ToolConfig{
+		{Name: "kill", Description: "kill", Command: "sh", Arguments: []string{"-c", "kill -9 $$"}},
+	})
+	if err != nil {
+		t.Fatalf("NewRegistry: %v", err)
+	}
+
+	result, err := reg.Execute(context.Background(), "kill", "{}")
+	if err != nil {
+		t.Fatalf("Execute: %v", err)
+	}
+	// The shell kills itself ($$ is its own PID) so that the direct
+	// child dies by signal and ExitCode reports -1.
+	if result.ProcessState.ExitCode() != -1 {
+		t.Errorf("ExitCode = %d, want -1 (killed by signal)", result.ProcessState.ExitCode())
+	}
+	if !strings.Contains(result.ProcessState.String(), "signal:") {
+		t.Errorf("ProcessState.String() = %q, want signal info", result.ProcessState.String())
+	}
+}