fix more docs and do some renaming for clarification

Author: dsyme

pkg/cli/copilot_agent.go

@@ -12,69 +12,69 @@ import (
 	"github.com/github/gh-aw/pkg/workflow"
 )
 
-var copilotAgentLog = logger.New("cli:copilot_agent")
+var copilotCodingAgentLog = logger.New("cli:copilot_agent")
 
-// CopilotAgentDetector contains heuristics to detect if a workflow run was executed by GitHub Copilot coding agent
-type CopilotAgentDetector struct {
+// CopilotCodingAgentDetector contains heuristics to detect if a workflow run was executed by GitHub Copilot coding agent
+type CopilotCodingAgentDetector struct {
 	runDir       string
 	verbose      bool
 	workflowPath string // Optional: workflow file path from GitHub API (e.g., .github/workflows/copilot-swe-agent.yml)
 }
 
-// NewCopilotAgentDetector creates a new detector for GitHub Copilot coding agent runs
-func NewCopilotAgentDetector(runDir string, verbose bool) *CopilotAgentDetector {
-	return &CopilotAgentDetector{
+// NewCopilotCodingAgentDetector creates a new detector for GitHub Copilot coding agent runs
+func NewCopilotCodingAgentDetector(runDir string, verbose bool) *CopilotCodingAgentDetector {
+	return &CopilotCodingAgentDetector{
 		runDir:  runDir,
 		verbose: verbose,
 	}
 }
 
-// NewCopilotAgentDetectorWithPath creates a detector with workflow path hint
-func NewCopilotAgentDetectorWithPath(runDir string, verbose bool, workflowPath string) *CopilotAgentDetector {
-	return &CopilotAgentDetector{
+// NewCopilotCodingAgentDetectorWithPath creates a detector with workflow path hint
+func NewCopilotCodingAgentDetectorWithPath(runDir string, verbose bool, workflowPath string) *CopilotCodingAgentDetector {
+	return &CopilotCodingAgentDetector{
 		runDir:       runDir,
 		verbose:      verbose,
 		workflowPath: workflowPath,
 	}
 }
 
-// IsGitHubCopilotAgent uses heuristics to determine if this run was executed by GitHub Copilot coding agent
+// IsGitHubCopilotCodingAgent uses heuristics to determine if this run was executed by GitHub Copilot coding agent
 // (not the Copilot CLI engine or agentic workflows)
-func (d *CopilotAgentDetector) IsGitHubCopilotAgent() bool {
-	copilotAgentLog.Printf("Detecting if run is GitHub Copilot coding agent: %s", d.runDir)
+func (d *CopilotCodingAgentDetector) IsGitHubCopilotCodingAgent() bool {
+	copilotCodingAgentLog.Printf("Detecting if run is GitHub Copilot coding agent: %s", d.runDir)
 
 	// If aw_info.json exists, this is an agentic workflow, NOT a GitHub Copilot coding agent run
 	awInfoPath := filepath.Join(d.runDir, "aw_info.json")
 	if _, err := os.Stat(awInfoPath); err == nil {
-		copilotAgentLog.Print("Found aw_info.json - this is an agentic workflow, not a GitHub Copilot coding agent")
+		copilotCodingAgentLog.Print("Found aw_info.json - this is an agentic workflow, not a GitHub Copilot coding agent")
 		return false
 	}
 
 	// Heuristic 1: Check workflow path if provided (most reliable hint from GitHub API)
 	if d.hasAgentWorkflowPath() {
-		copilotAgentLog.Print("Detected copilot-swe-agent in workflow path")
+		copilotCodingAgentLog.Print("Detected copilot-swe-agent in workflow path")
 		return true
 	}
 
 	// Heuristic 2: Check for agent-specific log patterns
 	if d.hasAgentLogPatterns() {
-		copilotAgentLog.Print("Detected agent log patterns")
+		copilotCodingAgentLog.Print("Detected agent log patterns")
 		return true
 	}
 
 	// Heuristic 3: Check for agent-specific artifacts
 	if d.hasAgentArtifacts() {
-		copilotAgentLog.Print("Detected agent artifacts")
+		copilotCodingAgentLog.Print("Detected agent artifacts")
 		return true
 	}
 
-	copilotAgentLog.Print("No GitHub Copilot coding agent indicators found")
+	copilotCodingAgentLog.Print("No GitHub Copilot coding agent indicators found")
 	return false
 }
 
 // hasAgentWorkflowPath checks if the workflow path indicates a Copilot coding agent run
 // The workflow ID is always "copilot-swe-agent" for GitHub Copilot coding agent runs
-func (d *CopilotAgentDetector) hasAgentWorkflowPath() bool {
+func (d *CopilotCodingAgentDetector) hasAgentWorkflowPath() bool {
 	if d.workflowPath == "" {
 		return false
 	}
@@ -97,7 +97,7 @@ func (d *CopilotAgentDetector) hasAgentWorkflowPath() bool {
 }
 
 // hasAgentLogPatterns checks log files for patterns specific to GitHub Copilot coding agent
-func (d *CopilotAgentDetector) hasAgentLogPatterns() bool {
+func (d *CopilotCodingAgentDetector) hasAgentLogPatterns() bool {
 	// Patterns that indicate GitHub Copilot coding agent (not Copilot CLI)
 	agentPatterns := []*regexp.Regexp{
 		regexp.MustCompile(`(?i)github.*copilot.*agent`),
@@ -141,7 +141,7 @@ func (d *CopilotAgentDetector) hasAgentLogPatterns() bool {
 }
 
 // hasAgentArtifacts checks for artifacts specific to GitHub Copilot coding agent runs
-func (d *CopilotAgentDetector) hasAgentArtifacts() bool {
+func (d *CopilotCodingAgentDetector) hasAgentArtifacts() bool {
 	// Check for agent-specific artifact patterns
 	agentArtifacts := []string{
 		"copilot-agent-output",
@@ -180,10 +180,10 @@ func readLogHeader(path string, maxBytes int) (string, error) {
 	return string(buffer[:n]), nil
 }
 
-// ParseCopilotAgentLogMetrics extracts metrics from GitHub Copilot coding agent logs
+// ParseCopilotCodingAgentLogMetrics extracts metrics from GitHub Copilot coding agent logs
 // This is different from Copilot CLI logs and requires specialized parsing
-func ParseCopilotAgentLogMetrics(logContent string, verbose bool) workflow.LogMetrics {
-	copilotAgentLog.Printf("Parsing GitHub Copilot coding agent log metrics: %d bytes", len(logContent))
+func ParseCopilotCodingAgentLogMetrics(logContent string, verbose bool) workflow.LogMetrics {
+	copilotCodingAgentLog.Printf("Parsing GitHub Copilot coding agent log metrics: %d bytes", len(logContent))
 
 	var metrics workflow.LogMetrics
 	var maxTokenUsage int
@@ -231,7 +231,7 @@ func ParseCopilotAgentLogMetrics(logContent string, verbose bool) workflow.LogMe
 				currentSequence = append(currentSequence, toolName)
 
 				if verbose {
-					copilotAgentLog.Printf("Found tool call: %s", toolName)
+					copilotCodingAgentLog.Printf("Found tool call: %s", toolName)
 				}
 			}
 		}
@@ -261,7 +261,7 @@ func ParseCopilotAgentLogMetrics(logContent string, verbose bool) workflow.LogMe
 	metrics.TokenUsage = maxTokenUsage
 	metrics.Turns = turns
 
-	copilotAgentLog.Printf("Parsed metrics: tokens=%d, cost=$%.4f, turns=%d",
+	copilotCodingAgentLog.Printf("Parsed metrics: tokens=%d, cost=$%.4f, turns=%d",
 		metrics.TokenUsage, metrics.EstimatedCost, metrics.Turns)
 
 	return metrics

pkg/cli/copilot_agent_test.go

@@ -11,7 +11,7 @@ import (
 	"github.com/github/gh-aw/pkg/logger"
 )
 
-func TestCopilotAgentDetector_IsGitHubCopilotAgent(t *testing.T) {
+func TestCopilotCodingAgentDetector_IsGitHubCopilotCodingAgent(t *testing.T) {
 	tests := []struct {
 		name           string
 		setupFunc      func(string) error
@@ -111,13 +111,13 @@ func TestCopilotAgentDetector_IsGitHubCopilotAgent(t *testing.T) {
 			}
 
 			// Run detector with workflow path if provided
-			var detector *CopilotAgentDetector
+			var detector *CopilotCodingAgentDetector
 			if tt.workflowPath != "" {
-				detector = NewCopilotAgentDetectorWithPath(tmpDir, false, tt.workflowPath)
+				detector = NewCopilotCodingAgentDetectorWithPath(tmpDir, false, tt.workflowPath)
 			} else {
-				detector = NewCopilotAgentDetector(tmpDir, false)
+				detector = NewCopilotCodingAgentDetector(tmpDir, false)
 			}
-			result := detector.IsGitHubCopilotAgent()
+			result := detector.IsGitHubCopilotCodingAgent()
 
 			if result != tt.expectedResult {
 				t.Errorf("Expected %v, got %v", tt.expectedResult, result)
@@ -126,7 +126,7 @@ func TestCopilotAgentDetector_IsGitHubCopilotAgent(t *testing.T) {
 	}
 }
 
-func TestParseCopilotAgentLogMetrics(t *testing.T) {
+func TestParseCopilotCodingAgentLogMetrics(t *testing.T) {
 	tests := []struct {
 		name           string
 		logContent     string
@@ -189,7 +189,7 @@ Task step 1 complete
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			metrics := ParseCopilotAgentLogMetrics(tt.logContent, false)
+			metrics := ParseCopilotCodingAgentLogMetrics(tt.logContent, false)
 
 			if tt.expectedTurns > 0 && metrics.Turns != tt.expectedTurns {
 				t.Errorf("Expected %d turns, got %d", tt.expectedTurns, metrics.Turns)
@@ -288,7 +288,7 @@ func TestExtractErrorMessage(t *testing.T) {
 	}
 }
 
-func TestIntegration_CopilotAgentWithAudit(t *testing.T) {
+func TestIntegration_CopilotCodingAgentWithAudit(t *testing.T) {
 	// Create a temporary directory that simulates a GitHub Copilot coding agent run
 	// NOTE: GitHub Copilot coding agent runs do NOT have aw_info.json (that's for agentic workflows)
 	tmpDir, err := os.MkdirTemp("", "copilot-agent-integration-*")
@@ -314,8 +314,8 @@ Tool call: github_create_pr
 	}
 
 	// Verify detector recognizes this as a GitHub Copilot coding agent run (no aw_info.json)
-	detector := NewCopilotAgentDetector(tmpDir, false)
-	if !detector.IsGitHubCopilotAgent() {
+	detector := NewCopilotCodingAgentDetector(tmpDir, false)
+	if !detector.IsGitHubCopilotCodingAgent() {
 		t.Error("Expected GitHub Copilot coding agent to be detected from log patterns")
 	}
 
@@ -372,7 +372,7 @@ Task iteration 1
 Tool call: github
 ERROR: Test error
 `
-	metrics := ParseCopilotAgentLogMetrics(logContent, false)
+	metrics := ParseCopilotCodingAgentLogMetrics(logContent, false)
 
 	// Verify the returned type is workflow.LogMetrics
 	var _ = metrics

pkg/cli/logs_metrics.go

@@ -42,16 +42,16 @@ func extractLogMetrics(logDir string, verbose bool, workflowPath ...string) (Log
 	}
 
 	// First check if this is a GitHub Copilot coding agent run (not Copilot CLI)
-	var detector *CopilotAgentDetector
+	var detector *CopilotCodingAgentDetector
 	if len(workflowPath) > 0 && workflowPath[0] != "" {
-		detector = NewCopilotAgentDetectorWithPath(logDir, verbose, workflowPath[0])
+		detector = NewCopilotCodingAgentDetectorWithPath(logDir, verbose, workflowPath[0])
 	} else {
-		detector = NewCopilotAgentDetector(logDir, verbose)
+		detector = NewCopilotCodingAgentDetector(logDir, verbose)
 	}
-	isGitHubCopilotAgent := detector.IsGitHubCopilotAgent()
-	logsMetricsLog.Printf("GitHub Copilot coding agent detected: %v", isGitHubCopilotAgent)
+	isGitHubCopilotCodingAgent := detector.IsGitHubCopilotCodingAgent()
+	logsMetricsLog.Printf("GitHub Copilot coding agent detected: %v", isGitHubCopilotCodingAgent)
 
-	if isGitHubCopilotAgent && verbose {
+	if isGitHubCopilotCodingAgent && verbose {
 		fmt.Fprintln(os.Stderr, console.FormatInfoMessage("Detected GitHub Copilot coding agent run, using specialized parser"))
 	}
 
@@ -143,7 +143,7 @@ func extractLogMetrics(logDir string, verbose bool, workflowPath ...string) (Log
 			!strings.Contains(fileName, "aw_output") &&
 			fileName != constants.AgentOutputFilename {
 
-			fileMetrics, err := parseLogFileWithEngine(path, detectedEngine, isGitHubCopilotAgent, verbose)
+			fileMetrics, err := parseLogFileWithEngine(path, detectedEngine, isGitHubCopilotCodingAgent, verbose)
 			if err != nil && verbose {
 				fmt.Fprintln(os.Stderr, console.FormatWarningMessage(fmt.Sprintf("Failed to parse log file %s: %v", path, err)))
 				return nil // Continue processing other files

pkg/cli/logs_parsing_engines.go

@@ -21,8 +21,8 @@ import (
 var logsParsingEnginesLog = logger.New("cli:logs_parsing_engines")
 
 // parseLogFileWithEngine parses a log file using a specific engine or falls back to auto-detection
-func parseLogFileWithEngine(filePath string, detectedEngine workflow.CodingAgentEngine, isGitHubCopilotAgent bool, verbose bool) (LogMetrics, error) {
-	logsParsingEnginesLog.Printf("Parsing log file: %s, isGitHubCopilotAgent=%v", filePath, isGitHubCopilotAgent)
+func parseLogFileWithEngine(filePath string, detectedEngine workflow.CodingAgentEngine, isGitHubCopilotCodingAgent bool, verbose bool) (LogMetrics, error) {
+	logsParsingEnginesLog.Printf("Parsing log file: %s, isGitHubCopilotCodingAgent=%v", filePath, isGitHubCopilotCodingAgent)
 	// Read the entire log file at once to avoid JSON parsing issues from chunked reading
 	content, err := os.ReadFile(filePath)
 	if err != nil {
@@ -34,9 +34,9 @@ func parseLogFileWithEngine(filePath string, detectedEngine workflow.CodingAgent
 	logsParsingEnginesLog.Printf("Read %d bytes from log file", len(logContent))
 
 	// If this is a GitHub Copilot coding agent run, use the specialized parser
-	if isGitHubCopilotAgent {
+	if isGitHubCopilotCodingAgent {
 		logsParsingEnginesLog.Print("Using GitHub Copilot coding agent parser")
-		return ParseCopilotAgentLogMetrics(logContent, verbose), nil
+		return ParseCopilotCodingAgentLogMetrics(logContent, verbose), nil
 	}
 
 	// If we have a detected engine from aw_info.json, use it directly

pkg/workflow/agentic_engine.go

@@ -460,10 +460,10 @@ func (r *EngineRegistry) GetAllEngines() []CodingAgentEngine {
 	return engines
 }
 
-// GetCopilotAgentPlaywrightTools returns the list of playwright tools available in the copilot agent
+// GetPlaywrightTools returns the list of playwright tools available in the copilot agent
 // This matches the tools available in the copilot agent MCP server configuration
 // This is a shared function used by all engines for consistent playwright tool configuration
-func GetCopilotAgentPlaywrightTools() []any {
+func GetPlaywrightTools() []any {
 	tools := []string{
 		"browser_click",
 		"browser_close",

pkg/workflow/claude_tools.go

@@ -102,7 +102,7 @@ func (e *ClaudeEngine) expandNeutralToolsToClaudeTools(tools map[string]any) map
 	if _, hasPlaywright := tools["playwright"]; hasPlaywright {
 		// Create playwright as an MCP tool with the same tools available as copilot agent
 		playwrightMCP := map[string]any{
-			"allowed": GetCopilotAgentPlaywrightTools(),
+			"allowed": GetPlaywrightTools(),
 		}
 		result["playwright"] = playwrightMCP
 	}

pkg/workflow/codex_engine.go

@@ -413,7 +413,7 @@ func (e *CodexEngine) expandNeutralToolsToCodexTools(toolsConfig *ToolsConfig) *
 
 		// Also update the Custom map entry for playwright with allowed tools list
 		playwrightMCP := map[string]any{
-			"allowed": GetCopilotAgentPlaywrightTools(),
+			"allowed": GetPlaywrightTools(),
 		}
 		if playwrightConfig.Version != "" {
 			playwrightMCP["version"] = playwrightConfig.Version

pkg/workflow/codex_playwright_test.go

@@ -76,7 +76,7 @@ func TestCodexEnginePlaywrightToolsExpansion(t *testing.T) {
 				}
 
 				// Verify that all expected copilot agent tools are present
-				expectedTools := GetCopilotAgentPlaywrightTools()
+				expectedTools := GetPlaywrightTools()
 				if len(allowedSlice) != len(expectedTools) {
 					t.Errorf("Expected %d tools to match copilot agent tools, got %d", len(expectedTools), len(allowedSlice))
 				}