Skip to content

The cross-harness, self-improving memory layer for AI agents. Join our community: https://discord.com/invite/zdNChS2fBu

13.1 KB
Raw Blame
package cmd

import (
	"os"
	"path/filepath"
	"testing"
)

func writeGitHead(t *testing.T, repo, head string) {
	t.Helper()
	gitDir := filepath.Join(repo, ".git")
	if err := os.MkdirAll(gitDir, 0o755); err != nil {
		t.Fatalf("mkdir %s: %v", gitDir, err)
	}
	if err := os.WriteFile(filepath.Join(gitDir, "HEAD"), []byte(head), 0o644); err != nil {
		t.Fatalf("write HEAD: %v", err)
	}
}

func TestResolveBranchPrefersRuntimeProvidedBranch(t *testing.T) {
	repo := t.TempDir()
	writeGitHead(t, repo, "ref: refs/heads/local-branch\n")

	got := resolveBranch(map[string]interface{}{"git_branch": "cloud-branch"}, repo)
	if got != "cloud-branch" {
		t.Fatalf("resolveBranch = %q, want runtime-provided cloud-branch", got)
	}
}

func TestResolveBranchDisabledByEnv(t *testing.T) {
	repo := t.TempDir()
	writeGitHead(t, repo, "ref: refs/heads/feature/local\n")

	for _, value := range []string{"1", "true", "YES"} {
		t.Setenv("BEACON_DISABLE_GIT_METADATA", value)
		if got := resolveBranch(map[string]interface{}{}, repo); got != "" {
			t.Fatalf("resolveBranch = %q, want empty with BEACON_DISABLE_GIT_METADATA=%s", got, value)
		}
		// Runtime-provided branch still passes through when disabled.
		if got := resolveBranch(map[string]interface{}{"git_branch": "cloud-branch"}, repo); got != "cloud-branch" {
			t.Fatalf("resolveBranch = %q, want runtime-provided branch to pass through", got)
		}
	}

	t.Setenv("BEACON_DISABLE_GIT_METADATA", "0")
	if got := resolveBranch(map[string]interface{}{}, repo); got != "feature/local" {
		t.Fatalf("resolveBranch = %q, want feature/local with disable flag off", got)
	}
}

func TestRunPromptSubmitEmitsLocalGitBranch(t *testing.T) {
	setupHookConfigDirs(t)
	platformFlag = "cursor"
	logPath := filepath.Join(t.TempDir(), "runtime.jsonl")
	t.Setenv("BEACON_ENDPOINT_LOG", logPath)

	repo := t.TempDir()
	writeGitHead(t, repo, "ref: refs/heads/feature/local\n")

	runHookWithInput(t, runPromptSubmit, map[string]interface{}{
		"conversation_id": "conv-branch",
		"hook_event_name": "beforeSubmitPrompt",
		"workspace_roots": []interface{}{repo},
		"prompt":          "hello",
	})

	event := lastEndpointEvent(t, logPath)
	if got := event["branch"]; got != "feature/local" {
		t.Fatalf("branch = %q, want feature/local", got)
	}
	if got := event["repository"]; got != repo {
		t.Fatalf("repository = %q, want %q", got, repo)
	}
}

func TestRunPromptSubmitOmitsBranchOutsideRepo(t *testing.T) {
	setupHookConfigDirs(t)
	platformFlag = "cursor"
	logPath := filepath.Join(t.TempDir(), "runtime.jsonl")
	t.Setenv("BEACON_ENDPOINT_LOG", logPath)

	runHookWithInput(t, runPromptSubmit, map[string]interface{}{
		"conversation_id": "conv-no-repo",
		"hook_event_name": "beforeSubmitPrompt",
		"workspace_roots": []interface{}{t.TempDir()},
		"prompt":          "hello",
	})

	event := lastEndpointEvent(t, logPath)
	if branch, ok := event["branch"]; ok {
		t.Fatalf("branch = %q, want no branch field outside a repo", branch)
	}
}

// opencode events are written by their own mapper rather than through emitHookEvent, so the
// workspace enrichment has to be applied there explicitly. Regression for f46a0295 ("Fill branch on
// hook emitters that bypass emitHookEvent").
func TestRunOpenCodeEventEmitsWorkspaceAndLocalGitBranch(t *testing.T) {
	setupHookConfigDirs(t)
	platformFlag = "opencode"
	logPath := filepath.Join(t.TempDir(), "runtime.jsonl")
	t.Setenv("BEACON_ENDPOINT_LOG", logPath)

	repo := t.TempDir()
	writeGitHead(t, repo, "ref: refs/heads/feature/opencode\n")

	runHookWithInput(t, runOpenCodeEvent, map[string]interface{}{
		"type":       "command.executed",
		"session_id": "oc-branch",
		"cwd":        repo,
		"command":    "ls",
	})

	event := lastEndpointEvent(t, logPath)
	if got := event["branch"]; got != "feature/opencode" {
		t.Fatalf("branch = %q, want feature/opencode", got)
	}
	if got := event["repository"]; got != repo {
		t.Fatalf("repository = %q, want %q", got, repo)
	}
	if got := leaf(event, "session", "working_directory"); got != repo {
		t.Fatalf("session.working_directory = %q, want %q", got, repo)
	}
}

func TestRunPostToolFileEditEmitsLocalGitBranch(t *testing.T) {
	setupHookConfigDirs(t)
	platformFlag = "cursor"
	logPath := filepath.Join(t.TempDir(), "runtime.jsonl")
	t.Setenv("BEACON_ENDPOINT_LOG", logPath)

	repo := t.TempDir()
	writeGitHead(t, repo, "ref: refs/heads/feature/edit\n")
	editedFile := filepath.Join(repo, "pkg", "main.go")

	// No workspace_roots or cwd in the payload: branch must resolve from the
	// edited file's own directory.
	runHookWithInput(t, runPostTool, map[string]interface{}{
		"conversation_id": "conv-edit",
		"hook_event_name": "afterFileEdit",
		"file_path":       editedFile,
		"edits": []interface{}{
			map[string]interface{}{"old_string": "old line", "new_string": "new line"},
		},
	})

	event := lastEndpointEvent(t, logPath)
	if action := event["event"].(map[string]interface{})["action"]; action != "file.modified" {
		t.Fatalf("event.action = %q, want file.modified", action)
	}
	if got := event["branch"]; got != "feature/edit" {
		t.Fatalf("branch = %q, want feature/edit", got)
	}
	// The file-dir fallback must not masquerade as the workspace path.
	if repository, ok := event["repository"]; ok {
		t.Fatalf("repository = %q, want no repository without a payload cwd", repository)
	}
}

func TestRunPostToolFileEditEmitsWorkspaceFields(t *testing.T) {
	setupHookConfigDirs(t)
	platformFlag = "cursor"
	logPath := filepath.Join(t.TempDir(), "runtime.jsonl")
	t.Setenv("BEACON_ENDPOINT_LOG", logPath)

	repo := t.TempDir()
	writeGitHead(t, repo, "ref: refs/heads/feature/edit\n")
	editedFile := filepath.Join(repo, "pkg", "main.go")

	runHookWithInput(t, runPostTool, map[string]interface{}{
		"conversation_id": "conv-edit-ws",
		"hook_event_name": "afterFileEdit",
		"workspace_roots": []interface{}{repo},
		"file_path":       editedFile,
		"edits": []interface{}{
			map[string]interface{}{"old_string": "old line", "new_string": "new line"},
		},
	})

	event := lastEndpointEvent(t, logPath)
	if got := event["repository"]; got != repo {
		t.Fatalf("repository = %q, want %q", got, repo)
	}
	session := event["session"].(map[string]interface{})
	if got := session["working_directory"]; got != repo {
		t.Fatalf("session.working_directory = %q, want %q", got, repo)
	}
	if got := session["id"]; got != "conv-edit-ws" {
		t.Fatalf("session.id = %q, want conv-edit-ws", got)
	}
	if got := event["branch"]; got != "feature/edit" {
		t.Fatalf("branch = %q, want feature/edit", got)
	}
}

func TestToolFieldsMapsMCPGenAIStandardFields(t *testing.T) {
	tests := []struct {
		name       string
		toolName   string
		toolInput  map[string]interface{}
		wantServer string
		wantTool   string
	}{
		{
			name:     "cursor tool name",
			toolName: "MCP:get_organizations",
			toolInput: map[string]interface{}{
				"jsonrpc_request_id":       "req-1",
				"jsonrpc_protocol_version": "2.0",
				"mcp_protocol_version":     "2025-06-18",
				"mcp_session_id":           "mcp-session",
				"network_transport":        "pipe",
			},
			wantTool: "get_organizations",
		},
		{
			name:       "claude tool name",
			toolName:   "mcp__memory__write",
			toolInput:  map[string]interface{}{},
			wantServer: "memory",
			wantTool:   "write",
		},
		{
			name:       "payload server tool wins",
			toolName:   "MCP:derived_tool",
			toolInput:  map[string]interface{}{"server_name": "linear", "tool_name": "issue-get"},
			wantServer: "linear",
			wantTool:   "issue-get",
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			fields := toolFieldsWithResponse(tt.toolName, tt.toolInput, map[string]interface{}{"ok": true})
			mcp := fields["mcp"].(map[string]interface{})
			if mcp["server"] != tt.wantServer || mcp["tool"] != tt.wantTool {
				t.Fatalf("mcp = %#v, want server=%q tool=%q", mcp, tt.wantServer, tt.wantTool)
			}
			method := mcp["method"].(map[string]interface{})
			if method["name"] != "tools/call" {
				t.Fatalf("mcp.method = %#v, want tools/call", method)
			}
			genAI := fields["gen_ai"].(map[string]interface{})
			if op := genAI["operation"].(map[string]interface{})["name"]; op != "execute_tool" {
				t.Fatalf("gen_ai.operation = %q, want execute_tool", op)
			}
			tool := genAI["tool"].(map[string]interface{})
			if tool["name"] != tt.wantTool {
				t.Fatalf("gen_ai.tool = %#v, want name %q", tool, tt.wantTool)
			}
			call := tool["call"].(map[string]interface{})
			if len(tt.toolInput) > 0 && call["arguments"] == nil {
				t.Fatalf("gen_ai.tool.call = %#v, want arguments", call)
			}
			if call["result"] == nil {
				t.Fatalf("gen_ai.tool.call = %#v, want result", call)
			}
		})
	}
}

func TestToolFieldsMapsMCPTransportContext(t *testing.T) {
	fields := toolFields("MCP:read_resource", map[string]interface{}{
		"resource_uri":             "file:///tmp/report.md",
		"jsonrpc_request_id":       "request-7",
		"jsonrpc":                  "2.0",
		"network_protocol_name":    "HTTP",
		"network_protocol_version": "2",
		"network_transport":        "TCP",
		"server_address":           "example.com",
		"server_port":              "443",
		"status_code":              "OK",
	})
	if got := fields["jsonrpc"].(map[string]interface{})["request"].(map[string]interface{})["id"]; got != "request-7" {
		t.Fatalf("jsonrpc.request.id = %q, want request-7", got)
	}
	if got := fields["network"].(map[string]interface{})["transport"]; got != "tcp" {
		t.Fatalf("network.transport = %q, want tcp", got)
	}
	if got := fields["server"].(map[string]interface{})["port"]; got != 443 {
		t.Fatalf("server.port = %#v, want 443", got)
	}
	if got := fields["rpc"].(map[string]interface{})["response"].(map[string]interface{})["status_code"]; got != "OK" {
		t.Fatalf("rpc.response.status_code = %q, want OK", got)
	}
	mcp := fields["mcp"].(map[string]interface{})
	if got := mcp["resource"].(map[string]interface{})["uri"]; got != "file:///tmp/report.md" {
		t.Fatalf("mcp.resource.uri = %q, want resource URI", got)
	}
}

func TestToolFieldsDoesNotTreatMCPArgumentIDAsJSONRPCRequestID(t *testing.T) {
	fields := toolFields("MCP:get_issue", map[string]interface{}{
		"id":   "issue-123",
		"name": "Release blocker",
	})
	jsonrpc, ok := fields["jsonrpc"].(map[string]interface{})
	if !ok {
		return
	}
	if request, ok := jsonrpc["request"]; ok {
		t.Fatalf("jsonrpc.request = %#v, want no request from generic tool argument id", request)
	}
}

func TestToolFieldsIgnoresFalseMCPErrorField(t *testing.T) {
	fields := toolFieldsWithResponse("MCP:get_organizations", map[string]interface{}{}, map[string]interface{}{
		"error": false,
		"ok":    true,
	})
	if _, ok := fields["error"]; ok {
		t.Fatalf("fields should not include error for false MCP error field: %#v", fields["error"])
	}
}

func TestToolFieldsMapsTruthyMCPErrorField(t *testing.T) {
	fields := toolFieldsWithResponse("MCP:get_organizations", map[string]interface{}{}, map[string]interface{}{
		"error": true,
	})
	errorFields, ok := fields["error"].(map[string]interface{})
	if !ok {
		t.Fatalf("fields error missing or wrong type: %#v", fields["error"])
	}
	if got := errorFields["type"]; got != "tool_error" {
		t.Fatalf("error.type = %q, want tool_error", got)
	}
}

func TestToolFieldsDoesNotTreatGenericNameAsMCP(t *testing.T) {
	fields := toolFields("Write", map[string]interface{}{"name": "README.md"})
	if _, ok := fields["mcp"]; ok {
		t.Fatalf("non-MCP tool should not include mcp fields: %#v", fields)
	}
	if _, ok := fields["gen_ai"]; ok {
		t.Fatalf("non-MCP tool should not include gen_ai fields: %#v", fields)
	}
}

func TestToolFieldsDoesNotTreatGenericFlatTransportKeysAsMCP(t *testing.T) {
	fields := toolFieldsWithResponse("HTTPClient", map[string]interface{}{
		"method":           "GET",
		"protocol_version": "HTTP/2",
		"uri":              "https://example.com/report",
	}, map[string]interface{}{
		"status_code": "200",
	})
	if _, ok := fields["mcp"]; ok {
		t.Fatalf("non-MCP tool should not include mcp fields: %#v", fields)
	}
	if _, ok := fields["gen_ai"]; ok {
		t.Fatalf("non-MCP tool should not include gen_ai fields: %#v", fields)
	}
}

func TestToolFieldsDoesNotTreatGenericServerToolPairAsMCP(t *testing.T) {
	oldPlatform := platformFlag
	defer func() {
		platformFlag = oldPlatform
	}()
	platformFlag = "cursor"
	fields := toolFields("HTTPClient", map[string]interface{}{
		"server_name": "api",
		"tool_name":   "request",
	})
	if _, ok := fields["mcp"]; ok {
		t.Fatalf("non-MCP tool should not include mcp fields: %#v", fields)
	}
	if _, ok := fields["gen_ai"]; ok {
		t.Fatalf("non-MCP tool should not include gen_ai fields: %#v", fields)
	}
}

func TestToolFieldsMapsGenericFlatTransportKeysForKnownMCP(t *testing.T) {
	fields := toolFields("MCP:read_resource", map[string]interface{}{
		"method":           "resources/read",
		"protocol_version": "2025-06-18",
		"uri":              "file:///tmp/report.md",
	})
	mcp := fields["mcp"].(map[string]interface{})
	if got := mcp["method"].(map[string]interface{})["name"]; got != "resources/read" {
		t.Fatalf("mcp.method.name = %q, want resources/read", got)
	}
	if got := mcp["protocol"].(map[string]interface{})["version"]; got != "2025-06-18" {
		t.Fatalf("mcp.protocol.version = %q, want 2025-06-18", got)
	}
	if got := mcp["resource"].(map[string]interface{})["uri"]; got != "file:///tmp/report.md" {
		t.Fatalf("mcp.resource.uri = %q, want file URI", got)
	}
}