Merge branch 'main' into copilot/issue-intents-runtime-feature

Author: pelikhan

CONTRIBUTING.md

@@ -555,9 +555,9 @@ This project follows the GitHub Community Guidelines. Please be respectful and i
 
 Releases are defined in `.github/workflows/release.md` and triggered from the compiled GitHub Actions workflow.
 
-The team follows semantic versioning on a best-effort basis.
+The team follows a **weekly or bi-weekly minor release cadence**, similar to VS Code's release practices. Version numbers increment the minor component on each release cycle — not on the basis of change scope. Patch releases are reserved for urgent fixes between cycles; major releases are used for significant breaking changes only.
 
-> **Note:** The release workflow publishes the new version as a **prerelease** on GitHub with `latest=false`. Prereleases are floated for a few days. On Monday, maintainers promote the last known good prerelease to stable so `latest` resolves to that release.
+> **Note:** The release workflow publishes the new version as a **prerelease** on GitHub with `latest=false`. Prereleases are floated for a few days. On Monday, maintainers promote the last known good prerelease to stable so `latest` resolves to that release. Immediately after promotion, a new minor pre-release is kicked off to start the next cycle.
 
 ### Steps
 
@@ -589,10 +589,17 @@ The team follows semantic versioning on a best-effort basis.
 
    Users who install with `version: latest` (the default) will now receive the new release.
 
+5. **Start the next release cycle** _(immediately after promotion)_
+
+   Following the weekly/bi-weekly cadence, kick off a new `minor` release right after promoting the previous one to stable. Repeat steps 1–3 to publish it as a prerelease. This prerelease then floats until the next Monday, when it becomes the new stable release.
+
+   > [!TIP]
+   > Always select `minor` when starting a new cycle. Use `patch` only for urgent fixes within a cycle, and `major` only for significant breaking changes.
+
 ### Summary
 
 ```
-Launch release action
+Launch release action (minor)
         │
         ▼
 Workflow pushes tag & pauses
@@ -609,11 +616,14 @@ Approve the gh-aw-actions-release environment gate
         ▼
 Release published as prerelease 🎉
         │
-        ▼  (manual)
+        ▼  (Monday — manual)
 Promote prerelease → full release on GitHub Releases page
         │
         ▼
 'latest' now resolves to the new version ✅
+        │
+        ▼  (same day — start next cycle)
+Launch next minor release action → new prerelease published
 ```
 
 ## 🎯 Why This Contribution Model?

actions/setup/js/assign_agent_helpers.cjs

@@ -10,40 +10,77 @@ const { getErrorMessage } = require("./error_helpers.cjs");
  */
 
 /**
- * Map agent names to their GitHub bot login names
- * @type {Record<string, string>}
+ * Map agent names to their GitHub bot login aliases.
+ * Keep the most common/current alias first so logs have a stable primary name.
+ * @type {Record<string, string[]>}
  */
 const AGENT_LOGIN_NAMES = {
-  copilot: "copilot-swe-agent",
+  copilot: ["copilot-swe-agent", "github-copilot-enterprise", "github-copilot-enterprise[bot]", "github-copilot", "github-copilot[bot]"],
 };
 
+/**
+ * Normalize a GitHub login for internal matching.
+ * @param {string} login
+ * @returns {string}
+ */
+function normalizeLogin(login) {
+  return login.startsWith("@") ? login.slice(1) : login;
+}
+
+/**
+ * Reverse lookup of assignee aliases to canonical agent names.
+ * @type {Record<string, string>}
+ */
+const AGENT_NAME_BY_LOGIN = Object.fromEntries(Object.entries(AGENT_LOGIN_NAMES).flatMap(([agentName, logins]) => logins.map(login => [normalizeLogin(login), agentName])));
+
+/**
+ * GitHub can surface bots either via type="Bot" or a [bot] login suffix.
+ * Check both because assignee responses are not always consistent across endpoints.
+ * @param {{login?: string, type?: string}|null|undefined} assignee
+ * @returns {boolean}
+ */
+function isBotAssignee(assignee) {
+  return assignee?.type === "Bot" || Boolean(assignee?.login?.endsWith("[bot]"));
+}
+
+/**
+ * Return the known GitHub login aliases for an agent.
+ * @param {string} agentName
+ * @returns {string[]}
+ */
+function getAgentLogins(agentName) {
+  const logins = AGENT_LOGIN_NAMES[agentName];
+  if (!logins) return [];
+  return logins;
+}
+
 /**
  * Check if an assignee is a known coding agent (bot)
  * @param {string} assignee - Assignee name (may include @ prefix)
  * @returns {string|null} Agent name if it's a known agent, null otherwise
  */
 function getAgentName(assignee) {
   // Normalize: remove @ prefix if present
-  const normalized = assignee.startsWith("@") ? assignee.slice(1) : assignee;
+  const normalized = normalizeLogin(assignee);
 
   // Check if it's a known agent
   if (AGENT_LOGIN_NAMES[normalized]) {
     return normalized;
   }
-
-  return null;
+  return AGENT_NAME_BY_LOGIN[normalized] || null;
 }
 
 /**
  * Return list of coding agent bot login names that are currently available as assignable actors
- * (intersection of suggestedActors and known AGENT_LOGIN_NAMES values)
+ * in this repository, as determined by checkUserCanBeAssigned.
  * @param {string} owner
  * @param {string} repo
  * @param {Object} [githubClient] - Authenticated GitHub client (defaults to global github)
  * @returns {Promise<string[]>}
  */
 async function getAvailableAgentLogins(owner, repo, githubClient = github) {
-  const knownValues = Object.values(AGENT_LOGIN_NAMES);
+  // Deduplicate defensively so future alias additions across agents do not duplicate REST lookups.
+  const knownValues = [...new Set(Object.values(AGENT_LOGIN_NAMES).flat())];
   const available = [];
   for (const login of knownValues) {
     try {
@@ -63,6 +100,46 @@ async function getAvailableAgentLogins(owner, repo, githubClient = github) {
   return available.sort();
 }
 
+/**
+ * Return assignable bot logins from the repository assignee list.
+ * @param {string} owner
+ * @param {string} repo
+ * @param {Object} [githubClient]
+ * @returns {Promise<string[]>}
+ */
+async function getAssignableBots(owner, repo, githubClient = github) {
+  try {
+    const assignees = [];
+    let page = 1;
+    let pageData = [];
+    const MAX_PAGES = 5; // Limit to 5 pages (500 assignees) to bound API calls on large repositories
+
+    do {
+      const response = await githubClient.rest.issues.listAssignees({
+        owner,
+        repo,
+        per_page: 100,
+        page,
+      });
+      pageData = Array.isArray(response.data) ? response.data : [];
+      assignees.push(...pageData);
+      page++;
+    } while (pageData.length === 100 && page <= MAX_PAGES);
+
+    return [
+      ...new Set(
+        assignees
+          .filter(isBotAssignee)
+          .map(assignee => assignee.login)
+          .filter(Boolean)
+      ),
+    ].sort();
+  } catch (error) {
+    core.debug(`Failed to list assignable bots for ${owner}/${repo}: ${getErrorMessage(error)}`);
+    return [];
+  }
+}
+
 /**
  * Find an agent that can be assigned in the repository using REST
  * @param {string} owner - Repository owner
@@ -72,44 +149,66 @@ async function getAvailableAgentLogins(owner, repo, githubClient = github) {
  * @returns {Promise<string|null>} Agent ID or null if not found
  */
 async function findAgent(owner, repo, agentName, githubClient = github) {
-  const loginName = AGENT_LOGIN_NAMES[agentName];
-  if (!loginName) {
+  const loginNames = getAgentLogins(agentName);
+  if (loginNames.length === 0) {
     core.error(`Unknown agent: ${agentName}. Supported agents: ${Object.keys(AGENT_LOGIN_NAMES).join(", ")}`);
     return null;
   }
 
-  try {
-    await githubClient.rest.issues.checkUserCanBeAssigned({
-      owner,
-      repo,
-      assignee: loginName,
-    });
-    const { data: agentUser } = await githubClient.rest.users.getByUsername({ username: loginName });
-    return String(agentUser.id);
-  } catch (error) {
-    const errorMessage = getErrorMessage(error);
-    core.error(`Failed to find ${agentName} agent: ${errorMessage}`);
-    if (
-      errorMessage.includes("Bad credentials") ||
-      errorMessage.includes("Not Authenticated") ||
-      errorMessage.includes("Resource not accessible") ||
-      errorMessage.includes("Insufficient permissions") ||
-      errorMessage.includes("requires authentication")
-    ) {
-      throw error;
-    }
-    const available = await getAvailableAgentLogins(owner, repo, githubClient);
-    core.warning(`${agentName} coding agent (${loginName}) is not available as an assignee for this repository`);
-    if (available.length > 0) {
-      core.info(`Available assignable coding agents: ${available.join(", ")}`);
-    } else {
-      core.info("No coding agents are currently assignable in this repository.");
+  core.info(`Trying ${loginNames.length} ${agentName} assignee aliases: ${loginNames.join(", ")}`);
+
+  const aliasFailures = [];
+  for (const loginName of loginNames) {
+    try {
+      core.info(`Checking assignee alias: ${loginName}`);
+      await githubClient.rest.issues.checkUserCanBeAssigned({
+        owner,
+        repo,
+        assignee: loginName,
+      });
+    } catch (checkError) {
+      const errorMessage = getErrorMessage(checkError);
+      const status = checkError?.status;
+      const statusLabel = status ? ` (${status})` : "";
+      aliasFailures.push(`${loginName}${statusLabel}: ${errorMessage}`);
+      if (
+        errorMessage.includes("Bad credentials") ||
+        errorMessage.includes("Not Authenticated") ||
+        errorMessage.includes("Resource not accessible") ||
+        errorMessage.includes("Insufficient permissions") ||
+        errorMessage.includes("requires authentication")
+      ) {
+        core.error(`Failed to check assignee alias ${loginName} for ${agentName}: ${errorMessage}`);
+        throw checkError;
+      }
+      core.info(`Assignee alias ${loginName} was not assignable: ${errorMessage}`);
+      continue;
     }
-    if (agentName === "copilot") {
-      core.info("Please visit https://docs.github.com/en/copilot/using-github-copilot/using-copilot-coding-agent-to-work-on-tasks/about-assigning-tasks-to-copilot");
+    // Alias confirmed assignable — resolve the user ID separately
+    try {
+      const { data: agentUser } = await githubClient.rest.users.getByUsername({ username: loginName });
+      core.info(`Resolved ${agentName} agent via assignee alias ${loginName}`);
+      return String(agentUser.id);
+    } catch (lookupError) {
+      core.warning(`Alias ${loginName} is assignable but user lookup failed: ${getErrorMessage(lookupError)}`);
     }
-    return null;
   }
+
+  const bots = await getAssignableBots(owner, repo, githubClient);
+  core.warning(`${agentName} coding agent aliases are not available as assignees for this repository`);
+  core.info(`Assignee aliases tried: ${loginNames.join(", ")}`);
+  if (aliasFailures.length > 0) {
+    core.info(`Alias lookup results: ${aliasFailures.join(" | ")}`);
+  }
+  if (bots.length > 0) {
+    core.info(`Assignable bots in this repository: ${bots.join(", ")}`);
+  } else {
+    core.info("No assignable bots found in this repository.");
+  }
+  if (agentName === "copilot") {
+    core.info("Please visit https://docs.github.com/en/copilot/using-github-copilot/using-copilot-coding-agent-to-work-on-tasks/about-assigning-tasks-to-copilot");
+  }
+  return null;
 }
 
 /**
@@ -439,11 +538,7 @@ async function assignAgentToIssueByName(owner, repo, issueNumber, agentName) {
     core.info(`Looking for ${agentName} coding agent...`);
     const agentId = await findAgent(owner, repo, agentName);
     if (!agentId) {
-      const error = `${agentName} coding agent is not available for this repository`;
-      // Enrich with available agent logins
-      const available = await getAvailableAgentLogins(owner, repo);
-      const enrichedError = available.length > 0 ? `${error} (available agents: ${available.join(", ")})` : error;
-      return { success: false, error: enrichedError };
+      return { success: false, error: `${agentName} coding agent is not available for this repository` };
     }
     core.info(`Found ${agentName} coding agent (ID: ${agentId})`);
 
@@ -457,7 +552,8 @@ async function assignAgentToIssueByName(owner, repo, issueNumber, agentName) {
     core.info(`Issue context: ${issueDetails.issueId}`);
 
     // Check if agent is already assigned
-    if (issueDetails.currentAssignees.some(a => a.id === agentId || a.login === AGENT_LOGIN_NAMES[agentName])) {
+    const knownLogins = getAgentLogins(agentName);
+    if (issueDetails.currentAssignees.some(a => a.id === agentId || knownLogins.includes(a.login))) {
       core.info(`${agentName} is already assigned to issue #${issueNumber}`);
       return { success: true };
     }
@@ -481,7 +577,9 @@ async function assignAgentToIssueByName(owner, repo, issueNumber, agentName) {
 module.exports = {
   AGENT_LOGIN_NAMES,
   getAgentName,
+  getAgentLogins,
   getAvailableAgentLogins,
+  getAssignableBots,
   findAgent,
   getIssueDetails,
   getPullRequestDetails,