chore: Add test coverage, code cleanup (#21)

* chore: Enable reading multiple agent control schemas

* chore: Make main more maintainable

* chore: Add back in SHA validation

* chore: Add test coverage, remove duplicate tests, parameterize tests

Co-Authored-By: Claude <noreply@anthropic.com>

* chore: Fix small go formatting issues

* chore: Documentation updates

* chore: Update to agreed-upon agent types

* revert: Manual revert of chore: Enable reading multiple agent control schemas

---------

Co-authored-by: Claude <noreply@anthropic.com>

Author: mvicknr

.gitignore

@@ -1,5 +1,6 @@
 # Copied during tests from integration-test/agent-flow/
 .fleetControl/
+!integration-test/agent-flow/.fleetControl/
 
 # Build output
 agent-metadata-action

CLAUDE.md

@@ -2,7 +2,9 @@
 
 # Agent Metadata Action
 
-A GitHub Action that reads agent configuration metadata from the calling repository. This action parses the `.fleetControl/configurationDefinitions.yml` file and makes the configuration data available in New Relic.
+A GitHub Action that reads agent configuration metadata from the calling repository. There are 2 scearios to use this action:
+1. An agent release - This action parses the `.fleetControl/configurationDefinitions.yml` file and makes the configuration data and metadata available in New Relic.
+2. A docs update for an agent release - This action parses the frontmatter of the docs mdx files and makes the metadata available in New Relic.
 
 ## Installation
 
@@ -25,13 +27,14 @@ This action requires OAuth credentials to authenticate with New Relic services.
 These must be passed as action inputs using the `with:` parameter in your workflow.
 
 ### Example Workflow For Releasing a New Agent Version
-This action automatically checks out your repository at the specified version tag, then reads the `.fleetControl/configurationDefinitions.yml` file and other associated files in `/fleetControl` and saves the agent information in New Relic. The action handles the checkout internally, so you don't need to include a separate `actions/checkout` step. If you do not want to use this action, you can call New Relic directly to add the agent information.
+This action automatically checks out your repository at the specified version tag, then reads the `.fleetControl/configurationDefinitions.yml` file and other associated files in `/fleetControl` and saves the agent information in New Relic. 
 
 ```yaml
 name: Process Agent Metadata
 on:
-  push:
-    branches: [main]
+  release:
+    types:
+      - published
 
 jobs:
   read-metadata:
@@ -42,14 +45,13 @@ jobs:
         with:
           newrelic-client-id: ${{ secrets.OAUTH_CLIENT_ID }}
           newrelic-private-key: ${{ secrets.OAUTH_CLIENT_SECRET }}
-          agent-type: dotnet # Required: The type of agent (e.g., dotnet, java, python)
-          version: 1.0.0 # Required: will be used to check out appropriate release tag
+          agent-type: dotnet-agent # Required for agent release workflow: The type of agent (e.g., nodejs-agent, java-agent)
+          version: 1.0.0 # Required for agent release workflow: will be used to check out appropriate release tag
           cache: true  # Optional: Enable Go build cache (default: true)
 ```
 
-### Example Workflow For Updating Docs Metadata on an Existing Agent Version
-This action automatically checks out the calling repo's commit, detects the changed release notes and saves the agent metadata in New Relic. The action handles the checkout internally, so you don't need to include a separate `actions/checkout` step. If you do not want to use this action, you can call New Relic directly to add the agent metadata.
-
+### Example Workflow For Updating Docs Metadata for a new/existing Agent Version
+This action should be triggered on a push to the main docs branch. It will automatically detect the changed release notes in the push and save the agent metadata in New Relic.
 
 ```yaml
 name: Process Agent Metadata
@@ -75,30 +77,24 @@ For the agent scenario, the action expects a YAML file at `.fleetControl/configu
 
 ```yaml
 configurationDefinitions:
-  - platform: "kubernetes"  # or "host" or "all" if there is no distinction
+  - platform: "KUBERNETESCLUSTER"  # or "HOST" or "ALL" if there is no distinction
     description: "Description of the configuration"
-    type: "config-type"
+    type: "agent-config"
     version: "1.0.0" -- config schema version
-    format: "json"   -- format of the agent config file
+    format: "yml"   -- format of the agent config file
     schema: "./schemas/config-schema.json"
 ```
 
-**All fields are required.** The action validates each configuration entry and will fail with a clear error message if any required field is missing (version, platform, description, type, format, schema).
 
 **Dec 2025 - schema temporarily optional until full functionality is ready
 
 **Schema paths must be relative to the `.fleetControl` directory and cannot use directory traversal (`..`) for security.
 
 ## Building
 
-To build the action locally:
-
 ```bash
 # Build the binary
 go build -o agent-metadata-action ./cmd/agent-metadata-action
-
-# Run locally
-/bin/bash /Users/mvick/IdeaProjects/agent-metadata-action/run_local.sh 
 ```
 
 ## Testing

README.md

@@ -5,6 +5,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"os"
+	"path/filepath"
 
 	"agent-metadata-action/internal/client"
 	"agent-metadata-action/internal/config"
@@ -14,7 +15,7 @@ import (
 
 // metadataClient interface for testing
 type metadataClient interface {
-	SendMetadata(ctx context.Context, agentType string, metadata *models.AgentMetadata) error
+	SendMetadata(ctx context.Context, agentType string, agentVersion string, metadata *models.AgentMetadata) error
 }
 
 // createMetadataClientFunc is a variable that holds the function to create a metadata client
@@ -25,114 +26,151 @@ var createMetadataClientFunc = func(baseURL, token string) metadataClient {
 
 func main() {
 	if err := run(); err != nil {
-		fmt.Fprintf(os.Stderr, "::error::%v\n", err)
+		_, _ = fmt.Fprintf(os.Stderr, "::error::%v\n", err)
 		os.Exit(1)
 	}
 }
 
 func run() error {
-	workspace := config.GetWorkspace()
+	// Validate required environment and setup
+	workspace, token, err := validateEnvironment()
+	if err != nil {
+		return err
+	}
 
-	// Workspace is required
+	// Create metadataClient
+	ctx := context.Background()
+	metadataClient := createMetadataClientFunc(config.GetMetadataURL(), token)
+
+	// Determine which flow to execute
+	agentType := config.GetAgentType()
+	agentVersion := config.GetVersion()
+
+	if agentType != "" && agentVersion != "" {
+		return runAgentFlow(ctx, metadataClient, workspace, agentType, agentVersion)
+	}
+
+	return runDocsFlow(ctx, metadataClient)
+}
+
+// validateEnvironment checks required environment variables and workspace
+func validateEnvironment() (workspace string, token string, err error) {
+	workspace = config.GetWorkspace()
 	if workspace == "" {
-		return fmt.Errorf("GITHUB_WORKSPACE is required but not set")
+		return "", "", fmt.Errorf("GITHUB_WORKSPACE is required but not set")
 	}
 
-	// Validate workspace directory exists
 	if _, err := os.Stat(workspace); err != nil {
-		return fmt.Errorf("error reading configs: workspace directory does not exist: %s", workspace)
+		return "", "", fmt.Errorf("workspace directory does not exist: %s", workspace)
 	}
 
-	// Get OAuth token from environment (set by action.yml authentication step)
-	token := config.GetToken()
+	token = config.GetToken()
 	if token == "" {
-		return fmt.Errorf("NEWRELIC_TOKEN is required but not set")
+		return "", "", fmt.Errorf("NEWRELIC_TOKEN is required but not set")
 	}
-	fmt.Println("::notice::OAuth token loaded from environment")
 
-	// Create instrumentation client
-	ctx := context.Background()
-	metadataClient := createMetadataClientFunc(config.GetMetadataURL(), token)
+	fmt.Println("::notice::Environment validated successfully")
+	return workspace, token, nil
+}
 
-	agentType := config.GetAgentType()
-	agentVersion := config.GetVersion()
+// runAgentFlow handles the agent repository workflow
+func runAgentFlow(ctx context.Context, client metadataClient, workspace, agentType, agentVersion string) error {
+	fmt.Println("::debug::Running agent repository flow")
 
-	if agentType != "" && agentVersion != "" { // Scenario 1: Agent repo flow
-		fmt.Println("::debug::Agent scenario")
-		fleetControlPath := workspace + "/.fleetControl"
-		if _, err := os.Stat(fleetControlPath); err != nil {
-			return fmt.Errorf("error ./fleetControl folder does not exist: %s", fleetControlPath)
-		} else {
-			fmt.Printf("::debug::Reading config from workspace: %s\n", workspace)
-
-			configs, err := loader.ReadConfigurationDefinitions(workspace)
-			if err != nil {
-				return fmt.Errorf("error reading configs: %w", err)
-			}
-
-			fmt.Println("::notice::Successfully read configs file")
-			fmt.Printf("::debug::Found %d configs\n", len(configs))
-
-			// @todo need to update this to read a list of files for future use
-			agentControl, err := loader.LoadAndEncodeAgentControl(workspace)
-			if err != nil {
-				fmt.Printf("::debug::Unable to read agent control file: %s\n", workspace)
-			} else {
-				fmt.Println("::notice::Successfully read agent control file")
-			}
-
-			metadata := loader.LoadMetadataForAgents(agentVersion)
-
-			// @todo will need to add agentRequirements here in a future PR
-
-			agentMetadata := models.AgentMetadata{
-				ConfigurationDefinitions: configs,
-				Metadata:                 metadata,
-				AgentControl:             agentControl,
-			}
-
-			printJSON("Agent Metadata", agentMetadata)
-
-			// Send metadata to instrumentation service
-			fmt.Println("::debug::Sending metadata to instrumentation service...")
-			if err := metadataClient.SendMetadata(ctx, agentType, &agentMetadata); err != nil {
-				return fmt.Errorf("failed to send metadata: %w", err)
-			}
-			fmt.Println("::notice::Successfully sent metadata to instrumentation service")
-		}
-	} else { // Scenario 2: Docs flow
-		fmt.Println("::debug::Docs scenario")
-
-		metadata, err := loader.LoadMetadataForDocs()
-		if err != nil {
-			// warn but don't fail the docs push - this data is useful but not required at this time
-			fmt.Printf("::warn::Error reading metadata %s \n", err)
-		} else {
-			for _, currMetadata := range metadata {
-				fmt.Printf("::debug::Found metadata for %s %s \n", currMetadata.AgentType, currMetadata.AgentMetadataFromDocs["version"])
-				printJSON("Docs Metadata", currMetadata.AgentMetadataFromDocs)
-
-				currAgentMetadata := models.AgentMetadata{
-					Metadata: currMetadata.AgentMetadataFromDocs,
-				}
-
-				if err := metadataClient.SendMetadata(ctx, currMetadata.AgentType, &currAgentMetadata); err != nil {
-					fmt.Printf("::warn::Failed to send docs metadata to instrumentation service for agent type: %s \n", currMetadata.AgentType)
-				} else {
-					fmt.Printf("::notice::Successfully sent docs metadata to instrumentation service for agent type:  %s \n", currMetadata.AgentType)
-				}
-			}
+	// Check for .fleetControl directory
+	fleetControlPath := filepath.Join(workspace, config.GetRootFolderForAgentRepo())
+	if _, err := os.Stat(fleetControlPath); err != nil {
+		return fmt.Errorf("%s directory does not exist: %s", config.GetRootFolderForAgentRepo(), fleetControlPath)
+	}
+
+	// Load configuration definitions (required)
+	configs, err := loader.ReadConfigurationDefinitions(workspace)
+	if err != nil {
+		return fmt.Errorf("failed to read configuration definitions: %w", err)
+	}
+	fmt.Printf("::notice::Loaded %d configuration definitions\n", len(configs))
+
+	// Load agent control (optional)
+	agentControl, err := loader.LoadAndEncodeAgentControl(workspace)
+	if err != nil {
+		fmt.Println("::warn::Unable to load agent control files - continuing without them")
+	} else {
+		fmt.Printf("::notice::Loaded %d agent control files\n", len(agentControl))
+	}
+
+	// Build metadata
+	metadata := models.AgentMetadata{
+		ConfigurationDefinitions: configs,
+		Metadata:                 loader.LoadMetadataForAgents(agentVersion),
+		AgentControlDefinitions:  agentControl,
+	}
+
+	printJSON("Agent Metadata", metadata)
+
+	// Send to service
+	if err := client.SendMetadata(ctx, agentType, agentVersion, &metadata); err != nil {
+		return fmt.Errorf("failed to send metadata for %s: %w", agentType, err)
+	}
+
+	fmt.Printf("::notice::Successfully sent metadata for %s version %s\n", agentType, agentVersion)
+	return nil
+}
+
+// runDocsFlow handles the documentation repository workflow
+func runDocsFlow(ctx context.Context, client metadataClient) error {
+	fmt.Println("::debug::Running documentation flow")
+
+	// Load metadata from changed MDX files
+	metadataList, err := loader.LoadMetadataForDocs()
+	if err != nil {
+		return fmt.Errorf("failed to load metadata from docs: %w", err)
+	}
+
+	if len(metadataList) == 0 {
+		fmt.Println("::notice::No metadata changes detected")
+		return nil
+	}
+
+	fmt.Printf("::notice::Processing %d metadata entries\n", len(metadataList))
+
+	// Send each metadata entry separately
+	successCount := 0
+	for _, entry := range metadataList {
+		if err := sendDocsMetadata(ctx, client, entry); err != nil {
+			fmt.Printf("::warn::Failed to send metadata for %s: %v\n", entry.AgentType, err)
+			continue
 		}
+		successCount++
+	}
+
+	fmt.Printf("::notice::Successfully sent %d of %d metadata entries\n", successCount, len(metadataList))
+	return nil
+}
+
+// sendDocsMetadata sends a single docs metadata entry to the service
+func sendDocsMetadata(ctx context.Context, client metadataClient, entry loader.MetadataForDocs) error {
+	version, _ := entry.AgentMetadataFromDocs["version"].(string)
+
+	metadata := models.AgentMetadata{
+		Metadata: entry.AgentMetadataFromDocs,
+	}
+
+	printJSON(fmt.Sprintf("Docs Metadata (%s %s)", entry.AgentType, version), entry.AgentMetadataFromDocs)
+
+	if err := client.SendMetadata(ctx, entry.AgentType, version, &metadata); err != nil {
+		return err
 	}
 
+	fmt.Printf("::notice::Sent metadata for %s version %s\n", entry.AgentType, version)
 	return nil
 }
 
+// printJSON marshals data to JSON and prints it with a debug annotation
 func printJSON(label string, data any) {
 	jsonData, err := json.MarshalIndent(data, "", "  ")
 	if err != nil {
-		fmt.Fprintf(os.Stderr, "::error::Failed to marshal %s: %v\n", label, err)
-		os.Exit(1)
+		fmt.Printf("::debug::Failed to marshal %s: %v\n", label, err)
+		return
 	}
 	fmt.Printf("::debug::%s: %s\n", label, string(jsonData))
 }