Add issue intents runtime support

Co-authored-by: pelikhan <4175913+pelikhan@users.noreply.github.com>

Author: Copilot

actions/setup/js/issue_intents.cjs

@@ -0,0 +1,112 @@
+// @ts-check
+/// <reference types="@actions/github-script" />
+
+const { sanitizeLabelContent } = require("./sanitize_label_content.cjs");
+const { hasRuntimeFeature, parseRuntimeFeatures } = require("./runtime_features.cjs");
+
+const ISSUE_INTENTS_FEATURE = "issue_intents";
+const ISSUE_INTENT_CONFIDENCE_VALUES = new Set(["LOW", "MEDIUM", "HIGH"]);
+
+function hasIssueIntentsRuntimeFeature() {
+  if (typeof global.hasRuntimeFeature === "function") {
+    return global.hasRuntimeFeature(ISSUE_INTENTS_FEATURE);
+  }
+  return hasRuntimeFeature(parseRuntimeFeatures(process.env.GH_AW_RUNTIME_FEATURES), ISSUE_INTENTS_FEATURE);
+}
+
+function normalizeIssueIntentMetadata(source) {
+  if (!source || typeof source !== "object") {
+    return {};
+  }
+
+  /** @type {{ rationale?: string, confidence?: "LOW"|"MEDIUM"|"HIGH", suggest?: boolean }} */
+  const metadata = {};
+
+  if (typeof source.rationale === "string") {
+    const rationale = source.rationale.trim();
+    if (rationale) {
+      metadata.rationale = rationale;
+    }
+  }
+
+  if (source.confidence !== undefined && source.confidence !== null && source.confidence !== "") {
+    const confidence = String(source.confidence).trim().toUpperCase();
+    if (!ISSUE_INTENT_CONFIDENCE_VALUES.has(confidence)) {
+      throw new Error(`Invalid confidence ${JSON.stringify(source.confidence)}. Expected one of: LOW, MEDIUM, HIGH.`);
+    }
+    metadata.confidence = /** @type {"LOW"|"MEDIUM"|"HIGH"} */ confidence;
+  }
+
+  if (source.suggest !== undefined) {
+    if (typeof source.suggest !== "boolean") {
+      throw new Error(`Invalid suggest ${JSON.stringify(source.suggest)}. Expected a boolean value.`);
+    }
+    if (source.suggest) {
+      metadata.suggest = true;
+    }
+  }
+
+  return metadata;
+}
+
+function normalizeIssueIntentLabelSpecs(labels) {
+  if (!Array.isArray(labels)) {
+    return [];
+  }
+
+  return labels.map((label, index) => {
+    if (typeof label === "string") {
+      const name = sanitizeLabelContent(label);
+      if (!name) {
+        throw new Error(`Invalid labels[${index}] entry. Label names must be non-empty strings.`);
+      }
+      if (name.startsWith("-")) {
+        throw new Error(`Label removal is not permitted. Found line starting with '-': ${name}`);
+      }
+      return { name };
+    }
+
+    if (!label || typeof label !== "object" || typeof label.name !== "string") {
+      throw new Error(`Invalid labels[${index}] entry. Expected a string label name or an object with a string "name" field.`);
+    }
+
+    const name = sanitizeLabelContent(label.name);
+    if (!name) {
+      throw new Error(`Invalid labels[${index}] entry. Label names must be non-empty strings.`);
+    }
+    if (name.startsWith("-")) {
+      throw new Error(`Label removal is not permitted. Found line starting with '-': ${name}`);
+    }
+
+    return {
+      name,
+      ...normalizeIssueIntentMetadata(label),
+    };
+  });
+}
+
+function getIssueIntentLabelNames(labelSpecs) {
+  return labelSpecs.map(label => label.name);
+}
+
+function buildIssueIntentLabelUpdates(labelSpecs, labelIdByName) {
+  return labelSpecs.map(spec => {
+    const labelId = labelIdByName.get(spec.name.toLowerCase());
+    if (!labelId) {
+      throw new Error(`Label ${JSON.stringify(spec.name)} not found. Ensure the label exists in the target repository.`);
+    }
+
+    return {
+      labelId,
+      ...normalizeIssueIntentMetadata(spec),
+    };
+  });
+}
+
+module.exports = {
+  buildIssueIntentLabelUpdates,
+  getIssueIntentLabelNames,
+  hasIssueIntentsRuntimeFeature,
+  normalizeIssueIntentLabelSpecs,
+  normalizeIssueIntentMetadata,
+};

actions/setup/js/safe_output_type_validator.test.cjs

@@ -38,11 +38,14 @@ const SAMPLE_VALIDATION_CONFIG = {
   },
   update_issue: {
     defaultMax: 1,
-    customValidation: "requiresOneOf:status,title,body",
+    customValidation: "requiresOneOf:status,title,body,labels,assignees,milestone",
     fields: {
       status: { type: "string", enum: ["open", "closed"] },
       title: { type: "string", sanitize: true, maxLength: 128 },
       body: { type: "string", sanitize: true, maxLength: 65000 },
+      labels: { type: "array" },
+      assignees: { type: "array", itemType: "string", itemSanitize: true, itemMaxLength: 39 },
+      milestone: { optionalPositiveInteger: true },
       issue_number: { issueOrPRNumber: true },
     },
   },
@@ -94,6 +97,29 @@ const SAMPLE_VALIDATION_CONFIG = {
       repo: { type: "string", maxLength: 256 },
     },
   },
+  set_issue_type: {
+    defaultMax: 5,
+    fields: {
+      issue_number: { issueOrPRNumber: true },
+      issue_type: { required: true, type: "string", sanitize: true, maxLength: 128 },
+      rationale: { type: "string", sanitize: true, maxLength: 1024 },
+      confidence: { type: "string", enum: ["LOW", "MEDIUM", "HIGH"] },
+      suggest: { type: "boolean" },
+    },
+  },
+  set_issue_field: {
+    defaultMax: 5,
+    customValidation: "requiresOneOf:field_name,field_node_id",
+    fields: {
+      issue_number: { issueOrPRNumber: true },
+      field_name: { type: "string", sanitize: true, maxLength: 128 },
+      field_node_id: { type: "string", maxLength: 256 },
+      value: { required: true, type: "string", sanitize: true, maxLength: 256 },
+      rationale: { type: "string", sanitize: true, maxLength: 1024 },
+      confidence: { type: "string", enum: ["LOW", "MEDIUM", "HIGH"] },
+      suggest: { type: "boolean" },
+    },
+  },
   link_sub_issue: {
     defaultMax: 5,
     customValidation: "parentAndSubDifferent",
@@ -691,6 +717,14 @@ describe("safe_output_type_validator", () => {
       expect(result.isValid).toBe(true);
     });
 
+    it("should pass when update_issue only includes labels", async () => {
+      const { validateItem } = await import("./safe_output_type_validator.cjs");
+
+      const result = validateItem({ type: "update_issue", labels: [{ name: "bug", confidence: "HIGH" }] }, "update_issue", 1);
+
+      expect(result.isValid).toBe(true);
+    });
+
     it("should fail when none of the required fields are present", async () => {
       const { validateItem } = await import("./safe_output_type_validator.cjs");
 
@@ -822,6 +856,18 @@ describe("safe_output_type_validator", () => {
       expect(result.isValid).toBe(false);
       expect(result.error).toContain("must be 'open' or 'closed'");
     });
+
+    it("should validate issue intent confidence enums", async () => {
+      const { validateItem } = await import("./safe_output_type_validator.cjs");
+
+      const typeResult = validateItem({ type: "set_issue_type", issue_type: "Bug", confidence: "high", suggest: true }, "set_issue_type", 1);
+      expect(typeResult.isValid).toBe(true);
+      expect(typeResult.normalizedItem.confidence).toBe("HIGH");
+
+      const fieldResult = validateItem({ type: "set_issue_field", field_name: "Priority", value: "P1", confidence: "medium", rationale: "Customer escalation" }, "set_issue_field", 1);
+      expect(fieldResult.isValid).toBe(true);
+      expect(fieldResult.normalizedItem.confidence).toBe("MEDIUM");
+    });
   });
 
   describe("pattern validation", () => {