kandev/apps/backend/cmd/mock-agent/sequences.go

package main

import (
	"fmt"
	"strings"

	acp "github.com/coder/acp-go-sdk"
)

// scriptState holds mutable state shared across script commands and sequence emitters.
type scriptState struct {
	toolCallCounter int
	lastToolID      string
	// monitorTools maps user-supplied Monitor taskID -> generated toolCallID,
	// so e2e:monitor_event and e2e:monitor_end can reference an earlier
	// e2e:monitor_start by name without the script needing to track IDs.
	monitorTools map[string]acp.ToolCallId
}

// state is the process-wide script state. Use resetState() in tests
// to get a clean starting point instead of touching fields directly.
var state = &scriptState{monitorTools: map[string]acp.ToolCallId{}}

func resetState() {
	state = &scriptState{monitorTools: map[string]acp.ToolCallId{}}
}

func nextToolID() acp.ToolCallId {
	state.toolCallCounter++
	id := fmt.Sprintf("mock_tool_%04d", state.toolCallCounter)
	state.lastToolID = id
	return acp.ToolCallId(id)
}

// --- Atomic emitters ---

// emitThinking emits a thinking block with random delay.
func emitThinking(e *emitter, model string) {
	randomDelay(model)
	e.thought("Analyzing the request and considering the best approach...")
}

// emitReadFile emits a Read tool call using a real workspace file.
func emitReadFile(e *emitter, model string) {
	toolID := nextToolID()
	f := randomFile()
	snippet := readFileSnippet(f.absPath, 30)
	randomDelay(model)

	e.startTool(toolID, "Read "+f.relPath, acp.ToolKindRead,
		map[string]any{"file_path": f.absPath},
		acp.ToolCallLocation{Path: f.absPath})

	randomDelay(model)
	e.completeTool(toolID, map[string]any{"content": snippet})
}

// emitEditFile emits an Edit tool call with permission request.
func emitEditFile(e *emitter, model string) {
	toolID := nextToolID()
	f := randomFile()
	oldStr, newStr := pickEditableFragment(f.absPath)
	randomDelay(model)

	input := map[string]any{
		"file_path":  f.absPath,
		"old_string": oldStr,
		"new_string": newStr,
	}

	e.startTool(toolID, "Edit "+f.relPath, acp.ToolKindEdit, input,
		acp.ToolCallLocation{Path: f.absPath})

	if e.requestPermission(toolID, "Edit "+f.relPath, acp.ToolKindEdit, input) {
		e.completeTool(toolID, map[string]any{"result": "File edited successfully: " + f.absPath})
	} else {
		e.completeTool(toolID, map[string]any{"result": "Permission denied for Edit"})
		e.text("Permission denied for Edit, skipping.")
	}
}

// emitShellExec emits a Bash tool call with permission request.
func emitShellExec(e *emitter, model string) {
	toolID := nextToolID()
	randomDelay(model)

	input := map[string]any{
		"command":     "go test ./...",
		"description": "Run all tests",
	}

	e.startTool(toolID, "Run tests", acp.ToolKindExecute, input)

	if e.requestPermission(toolID, "Run tests", acp.ToolKindExecute, input) {
		e.completeTool(toolID, map[string]any{"output": "ok  \tgithub.com/example/project\t0.042s\nPASS"})
	} else {
		e.completeTool(toolID, map[string]any{"output": "Permission denied"})
		e.text("Permission denied for Bash, skipping.")
	}
}

// emitCodeSearch emits a Grep tool call using real workspace file paths.
func emitCodeSearch(e *emitter, model string) {
	toolID := nextToolID()
	randomDelay(model)

	searchPatterns := []string{"func ", "import ", "TODO", "return ", "error", "type "}
	pattern := searchPatterns[state.toolCallCounter%len(searchPatterns)]

	f := randomFile()
	e.startTool(toolID, "Search for \""+pattern+"\"", acp.ToolKindSearch,
		map[string]any{"pattern": pattern, "path": f.absPath})

	randomDelay(model)

	paths := randomFilePaths(3)
	var results []string
	for i, p := range paths {
		results = append(results, fmt.Sprintf("%s:%d:%s found here", p, (i+1)*10, strings.TrimSpace(pattern)))
	}
	e.completeTool(toolID, map[string]any{"matches": strings.Join(results, "\n")})
}

// emitSubagent emits a Task tool call with child tool calls.
func emitSubagent(e *emitter, model string) {
	taskToolID := nextToolID()
	randomDelay(model)

	e.startTool(taskToolID, "Explore codebase", acp.ToolKindOther,
		map[string]any{
			"description": "Explore codebase",
			"prompt":      "Find all files and summarize the project structure",
		})

	randomDelay(model)
	e.thought("Exploring the project structure...")
	randomDelay(model)

	paths := randomFilePaths(5)
	e.text(fmt.Sprintf("Found %d files. The project structure looks well-organized.", len(paths)))
	randomDelay(model)

	// Child glob tool call
	childToolID := nextToolID()
	e.startTool(childToolID, "Glob **/*", acp.ToolKindSearch,
		map[string]any{"pattern": "**/*"})
	randomDelay(model)
	e.completeTool(childToolID, map[string]any{"files": strings.Join(paths, "\n")})
	randomDelay(model)

	e.text("Project structure analysis complete.")
	randomDelay(model)
	e.completeTool(taskToolID, map[string]any{
		"result": fmt.Sprintf("Subagent completed: Found %d files across the project.", len(paths)),
	})
}

// emitTodo emits a TodoWrite tool call.
func emitTodo(e *emitter, model string) {
	toolID := nextToolID()
	randomDelay(model)

	e.startTool(toolID, "Update todo list", acp.ToolKindOther, map[string]any{
		"todos": []map[string]any{
			{"id": "1", "content": "Review code changes", "status": "in_progress"},
			{"id": "2", "content": "Run tests", "status": "pending"},
			{"id": "3", "content": "Update documentation", "status": "pending"},
		},
	})

	randomDelay(model)
	e.completeTool(toolID, map[string]any{"result": "Todo list updated: 3 items (1 in progress, 2 pending)"})
}

// emitMermaidSequence emits a rich markdown message containing mermaid diagrams.
func emitMermaidSequence(e *emitter, model string) {
	emitThinking(e, model)
	randomDelay(model)

	e.text("Here's an overview of the system architecture with diagrams:\n\n" +
		"## System Flow\n\n" +
		"The following flowchart shows the request processing pipeline:\n\n" +
		"```mermaid\n" +
		"flowchart TD\n" +
		"    A([Client Request]) --> B{Auth Check}\n" +
		"    B -->|Valid| C[API Gateway]\n" +
		"    B -->|Invalid| D[401 Unauthorized]\n" +
		"    C --> E[Load Balancer]\n" +
		"    E --> F[Service A]\n" +
		"    E --> G[Service B]\n" +
		"    F --> H[(Database)]\n" +
		"    G --> H\n" +
		"    H --> I[Response Builder]\n" +
		"    I --> J([Client Response])\n" +
		"```\n\n" +
		"## Sequence Diagram\n\n" +
		"Here's how the authentication flow works between components:\n\n" +
		"```mermaid\n" +
		"sequenceDiagram\n" +
		"    participant U as User\n" +
		"    participant FE as Frontend\n" +
		"    participant API as API Server\n" +
		"    participant DB as Database\n" +
		"    U->>FE: Login Request\n" +
		"    FE->>API: POST /auth/login\n" +
		"    API->>DB: Verify Credentials\n" +
		"    DB-->>API: User Record\n" +
		"    API-->>FE: JWT Token\n" +
		"    FE-->>U: Redirect to Dashboard\n" +
		"```\n\n" +
		"### Key Points\n\n" +
		"- All requests go through the **API Gateway** for rate limiting\n" +
		"- Authentication uses **JWT tokens** with a 24h expiry\n" +
		"- Services communicate via `gRPC` internally\n" +
		"- Database connections use a **connection pool** (max 50)\n")
}

// emitWebFetch emits a WebFetch tool call.
func emitWebFetch(e *emitter, model string) {
	toolID := nextToolID()
	randomDelay(model)

	e.startTool(toolID, "Fetch API docs", acp.ToolKindFetch, map[string]any{
		"url":    "https://example.com/api/docs",
		"prompt": "Extract the API endpoints and their descriptions",
	})

	randomDelay(model)
	e.completeTool(toolID, map[string]any{
		"content": "API Documentation:\n- GET /api/v1/users - List all users\n- POST /api/v1/users - Create a new user\n- GET /api/v1/users/:id - Get user by ID\n- PUT /api/v1/users/:id - Update user\n- DELETE /api/v1/users/:id - Delete user",
	})
}