Add debug logging

Signed-off-by: Kyle Squizzato <[email protected]>

Author: squizzi

.github/actions/pr-labels/src/index.js

@@ -35,141 +35,192 @@ const SEMANTIC_TYPE_TO_LABEL = {
 function extractSemanticType(message) {
   if (!message) return null;
 
+  core.debug(`Attempting to extract semantic type from: "${message}"`);
+
   // Match standard semantic commit format: type(scope): message
   const semanticRegex = /^(\w+)(?:\([\w-]+\))?:\s/;
   const match = message.match(semanticRegex);
 
   if (match && match[1]) {
-    return match[1].toLowerCase();
+    const type = match[1].toLowerCase();
+    core.debug(`Extracted semantic type: "${type}"`);
+    return type;
   }
 
+  core.debug("No semantic type found in message");
   return null;
 }
 
 async function run() {
   try {
     // get inputs
     const token = core.getInput("token", { required: true });
+    core.debug("Token retrieved successfully");
 
     // set up github client
     const octokit = github.getOctokit(token);
+    core.debug("GitHub client initialized");
 
     // Track if we added a label based on semantic commit
     let addedSemanticLabel = false;
 
     // fetch the list of labels
+    core.debug("Fetching current PR labels...");
     const labels = (
       await octokit.rest.issues.listLabelsOnIssue({
         ...github.context.repo,
         issue_number: github.context.issue.number,
       })
     ).data.map((label) => label.name);
-    core.debug(`Found labels: ${labels.join(", ")}`);
+    core.debug(`Found ${labels.length} labels: ${labels.join(", ")}`);
 
     // Get PR details to check for semantic commit messages
     const prNumber = github.context.issue.number;
+    core.debug(`Processing PR #${prNumber}`);
+
+    core.debug("Fetching PR details...");
     const { data: pullRequest } = await octokit.rest.pulls.get({
       ...github.context.repo,
       pull_number: prNumber,
     });
 
     // Get the PR title and HEAD commit message
     const prTitle = pullRequest.title;
+    core.debug(`PR title: "${prTitle}"`);
 
     // Get the HEAD commit message
+    core.debug("Fetching PR commits...");
     const { data: commits } = await octokit.rest.pulls.listCommits({
       ...github.context.repo,
       pull_number: prNumber,
     });
 
+    core.debug(`Found ${commits.length} commits in PR`);
     const headCommitMessage = commits.length > 0 ? commits[commits.length - 1].commit.message : null;
+    if (headCommitMessage) {
+      core.debug(`HEAD commit message: "${headCommitMessage}"`);
+    } else {
+      core.debug("No HEAD commit message found");
+    }
 
     // Try to extract semantic type from PR title or HEAD commit
+    core.debug("Extracting semantic type from PR title...");
     const prTitleType = extractSemanticType(prTitle);
+
+    core.debug("Extracting semantic type from HEAD commit...");
     const commitType = extractSemanticType(headCommitMessage);
 
     // Use PR title type first, then fall back to commit type
     const semanticType = prTitleType || commitType;
+    if (semanticType) {
+      core.debug(`Using semantic type: "${semanticType}"`);
+    } else {
+      core.debug("No semantic type found in PR title or HEAD commit");
+    }
 
     // If we found a semantic type that maps to one of our labels, add it if not present
     if (semanticType && SEMANTIC_TYPE_TO_LABEL[semanticType]) {
       const labelToAdd = SEMANTIC_TYPE_TO_LABEL[semanticType];
+      core.debug(`Semantic type "${semanticType}" maps to label "${labelToAdd}"`);
 
       // Only add the label if it's not already present
       if (!labels.includes(labelToAdd)) {
         core.info(`Adding label ${labelToAdd} based on semantic commit type: ${semanticType}`);
+
+        core.debug("Calling GitHub API to add label...");
         await octokit.rest.issues.addLabels({
           ...github.context.repo,
           issue_number: prNumber,
           labels: [labelToAdd],
         });
+        core.debug("Label added successfully via API");
 
         // Update our local labels array to include the new label
         labels.push(labelToAdd);
         addedSemanticLabel = true;
+        core.debug(`Updated local labels array: ${labels.join(", ")}`);
 
         // If we just added a label, give it time to apply
         if (addedSemanticLabel) {
           core.info("Added label based on semantic commit message. Waiting for label to apply...");
           // Short delay to allow the label to be properly registered
+          core.debug("Waiting 2 seconds for label to propagate...");
           await new Promise(resolve => setTimeout(resolve, 2000));
+          core.debug("Wait completed");
 
           // Refetch the labels to ensure we have the most up-to-date set
           core.info("Refetching labels after adding semantic label...");
+          core.debug("Calling GitHub API to get updated labels...");
           const updatedLabelsResponse = await octokit.rest.issues.listLabelsOnIssue({
             ...github.context.repo,
             issue_number: github.context.issue.number,
           });
 
           // Update our labels array with the freshly fetched labels
           const updatedLabels = updatedLabelsResponse.data.map((label) => label.name);
-          core.debug(`Updated labels after adding semantic label: ${updatedLabels.join(", ")}`);
+          core.debug(`Refetched ${updatedLabels.length} labels: ${updatedLabels.join(", ")}`);
 
           // Replace our labels array with the updated one
           labels.length = 0;
           updatedLabels.forEach(label => labels.push(label));
+          core.debug(`Updated local labels array after refetch: ${labels.join(", ")}`);
         }
+      } else {
+        core.debug(`Label "${labelToAdd}" already exists on PR, no need to add it`);
       }
+    } else if (semanticType) {
+      core.debug(`Semantic type "${semanticType}" does not map to any of our labels`);
     }
 
     // ensure exactly one primary label is set
+    core.debug("Checking for primary labels...");
     const primaryLabels = PRIMARY_LABELS.filter((label) =>
       labels.includes(label)
     );
-    core.debug(`Found primary labels: ${primaryLabels.join(", ")}`);
+    core.debug(`Found ${primaryLabels.length} primary labels: ${primaryLabels.join(", ")}`);
 
     if (primaryLabels.length !== 1) {
+      core.debug(`Primary label check failed: found ${primaryLabels.length} primary labels`);
       throw new Error(
         `Exactly one primary label must be set from [${PRIMARY_LABELS.join(", ")}]. Found: ${primaryLabels.join(", ")}`
       );
     }
+    core.debug("Primary label check passed");
 
     // if the primary label is a bug, ensure a bug label is set
     if (primaryLabels[0] === "type::bug") {
+      core.debug("Primary label is type::bug, checking for bug labels...");
       const bugLabels = BUG_LABELS.filter((label) => labels.includes(label));
-      core.debug(`type::bug is set, found bug labels: ${bugLabels.join(", ")}`);
+      core.debug(`Found ${bugLabels.length} bug labels: ${bugLabels.join(", ")}`);
       if (bugLabels.length !== 1) {
+        core.debug(`Bug label check failed: found ${bugLabels.length} bug labels`);
         throw new Error(
           `Exactly one bug label must be set for primary type::bug. Found: ${bugLabels.join(
             ", "
           )}`
         );
       }
+      core.debug("Bug label check passed");
     }
 
     // ensure no more than one severity label is set
+    core.debug("Checking for severity labels...");
     const severityLabels = SEVERITY_LABELS.filter((label) =>
       labels.includes(label)
     );
-    core.debug(`Found severity labels: ${severityLabels.join(", ")}`);
+    core.debug(`Found ${severityLabels.length} severity labels: ${severityLabels.join(", ")}`);
     if (severityLabels.length > 1) {
+      core.debug(`Severity label check failed: found ${severityLabels.length} severity labels`);
       throw new Error(
         `No more than one severity label may be set. Found: ${severityLabels.join(
           ", "
         )}`
       );
     }
+    core.debug("Severity label check passed");
+
   } catch (error) {
+    core.debug(`Error caught: ${error.message}`);
     if (error instanceof Error) core.setFailed(error.message);
   }
 }