@happyvertical/github-actions 0.74.8

package/dist/index.js

@@ -0,0 +1,637 @@
+import { c as createRepository, a as createProject, g as githubAPI, b as analyzeIssue, s as searchDuplicates, p as postTriageComment, d as postErrorComment } from "./index-v2-CqFKwTm8.js";
+import { A, L, S, e, f, h, i, j, k, l, m, n, o, q, r, t, u, v, w } from "./index-v2-CqFKwTm8.js";
+async function analyzePlanning(context) {
+  const systemPrompt = `You are a software development planning assistant for the ${context.owner}/${context.repo} repository.
+
+Repository: ${context.config.repoDescription}
+${context.config.packagePattern ? `Package pattern: ${context.config.packagePattern}` : ""}
+${context.config.packageExamples ? `Example packages: ${context.config.packageExamples.join(", ")}` : ""}
+
+Your task is to create a detailed implementation plan for issues. Analyze the requirements and provide:
+1. A clear summary of what needs to be done
+2. A step-by-step task breakdown
+3. Complexity assessment (simple, moderate, complex)
+4. Technical considerations
+5. Files likely to be affected
+6. Dependencies or blockers`;
+  const userPrompt = `Issue #${context.issueNumber}: ${context.issueTitle}
+
+${context.issueBody || "No description provided"}
+
+Please create a detailed implementation plan following this JSON structure:
+{
+  "summary": "Brief summary of the implementation",
+  "tasks": ["Step 1", "Step 2", "Step 3"],
+  "complexity": "simple|moderate|complex",
+  "considerations": ["Technical consideration 1", "Technical consideration 2"],
+  "affected_files": ["file1.ts", "file2.ts"],
+  "dependencies": ["Optional blocker or dependency"]
+}`;
+  console.log("AI Planning Analysis would be called here");
+  console.log("System:", systemPrompt);
+  console.log("User:", userPrompt);
+  return {
+    summary: `Implementation plan for: ${context.issueTitle}`,
+    tasks: [
+      "Analyze requirements and design approach",
+      "Implement core functionality",
+      "Add tests",
+      "Update documentation"
+    ],
+    complexity: "moderate",
+    considerations: [
+      "Ensure backward compatibility",
+      "Follow existing code patterns",
+      "Add comprehensive error handling"
+    ],
+    affected_files: [],
+    dependencies: []
+  };
+}
+function validateDefinitionOfReady(issue, hasPlanComment) {
+  const labels = issue.labels.map((l2) => typeof l2 === "string" ? l2 : l2.name);
+  return {
+    hasClearDescription: !!issue.body && issue.body.trim().length > 50,
+    hasTypeLabel: labels.some((l2) => l2.startsWith("type:")),
+    hasPriorityLabel: labels.some((l2) => l2.startsWith("priority:")),
+    hasSizeLabel: labels.some((l2) => l2.startsWith("size:")),
+    hasPlan: hasPlanComment,
+    noBlockers: !labels.some((l2) => l2 === "status: blocked")
+  };
+}
+function isReady(dor) {
+  return dor.hasClearDescription && dor.hasTypeLabel && dor.hasPriorityLabel && dor.hasSizeLabel && dor.hasPlan && dor.noBlockers;
+}
+function formatDefinitionOfReady(dor) {
+  const checkbox = (checked) => checked ? "[x]" : "[ ]";
+  return `## Definition of Ready
+
+${checkbox(dor.hasClearDescription)} Clear, actionable description
+${checkbox(dor.hasTypeLabel)} Type label applied
+${checkbox(dor.hasPriorityLabel)} Priority label applied
+${checkbox(dor.hasSizeLabel)} Size label applied
+${checkbox(dor.hasPlan)} Implementation plan documented
+${checkbox(dor.noBlockers)} No blocking dependencies
+
+${isReady(dor) ? "✅ **This issue is ready for implementation!**" : "⚠️ **This issue needs more work before it's ready.**"}`;
+}
+async function postPlanComment(repo, issueNumber, plan) {
+  const comment = `## 🤖 Implementation Plan
+
+### Summary
+${plan.summary}
+
+### Tasks
+${plan.tasks.map((task, i2) => `${i2 + 1}. ${task}`).join("\n")}
+
+### Complexity
+**${plan.complexity.charAt(0).toUpperCase() + plan.complexity.slice(1)}**
+
+### Technical Considerations
+${plan.considerations.map((c) => `- ${c}`).join("\n")}
+
+${plan.affected_files && plan.affected_files.length > 0 ? `### Affected Files
+${plan.affected_files.map((f2) => `- \`${f2}\``).join("\n")}` : ""}
+
+${plan.dependencies && plan.dependencies.length > 0 ? `### Dependencies
+${plan.dependencies.map((d) => `- ${d}`).join("\n")}` : ""}
+
+---
+*This plan was generated by AI. Please review and provide feedback in the comments.*`;
+  await repo.addComment(issueNumber, comment);
+}
+async function postReadyCheckComment(repo, issueNumber, dor) {
+  const comment = formatDefinitionOfReady(dor);
+  await repo.addComment(issueNumber, comment);
+}
+async function postPlanningErrorComment(repo, issueNumber, error) {
+  const comment = `## ⚠️ Planning Failed
+
+An error occurred while creating the implementation plan:
+
+\`\`\`
+${error.message}
+\`\`\`
+
+Please try again or create a manual implementation plan in the comments.`;
+  await repo.addComment(issueNumber, comment);
+}
+async function startPlanning(context) {
+  console.log(
+    `Starting planning for issue #${context.issueNumber}: ${context.issueTitle}`
+  );
+  try {
+    const repo = await createRepository(
+      context.token,
+      context.owner,
+      context.repo
+    );
+    await repo.addLabels(context.issueNumber, ["agent: planning"]);
+    console.log("Generating implementation plan...");
+    const plan = await analyzePlanning(context);
+    await postPlanComment(repo, context.issueNumber, plan);
+    console.log("✅ Planning started successfully");
+    return {
+      success: true,
+      plan
+    };
+  } catch (error) {
+    console.error("❌ Planning failed:", error.message);
+    try {
+      const repo = await createRepository(
+        context.token,
+        context.owner,
+        context.repo
+      );
+      await postPlanningErrorComment(repo, context.issueNumber, error);
+    } catch {
+    }
+    return {
+      success: false,
+      error: error.message
+    };
+  }
+}
+async function completePlanning(context) {
+  console.log(
+    `Completing planning for issue #${context.issueNumber}: ${context.issueTitle}`
+  );
+  try {
+    const repo = await createRepository(
+      context.token,
+      context.owner,
+      context.repo
+    );
+    const issue = await repo.getIssue(context.issueNumber);
+    const comments = await repo.listComments(context.issueNumber);
+    const hasPlanComment = comments.some(
+      (c) => c.body?.includes("Implementation Plan")
+    );
+    const dor = validateDefinitionOfReady(issue, hasPlanComment);
+    await postReadyCheckComment(repo, context.issueNumber, dor);
+    if (!isReady(dor)) {
+      console.log("⚠️ Issue does not meet Definition of Ready criteria");
+      return {
+        success: false,
+        error: "Issue does not meet Definition of Ready criteria"
+      };
+    }
+    await repo.removeLabel(context.issueNumber, "agent: planning");
+    if (context.config.projectId && context.config.statusFieldId && context.config.statusOptions) {
+      const project = await createProject(
+        context.token,
+        context.config.projectId,
+        context.config.statusFieldId,
+        context.config.statusOptions
+      );
+      const items = await project.listItems();
+      const itemId = items.find(
+        (item) => item.contentId === issue.id
+      )?.id;
+      if (itemId) {
+        await project.updateItemStatus(itemId, "Ready");
+      }
+    }
+    console.log("✅ Planning completed, moved to Ready");
+    return {
+      success: true
+    };
+  } catch (error) {
+    console.error("❌ Complete planning failed:", error.message);
+    return {
+      success: false,
+      error: error.message
+    };
+  }
+}
+async function githubRequest(context, method, path, body) {
+  const url = `https://api.github.com${path}`;
+  const headers = {
+    Authorization: `Bearer ${context.token}`,
+    Accept: "application/vnd.github+json",
+    "X-GitHub-Api-Version": "2022-11-28",
+    "Content-Type": "application/json"
+  };
+  const response = await fetch(url, {
+    method,
+    headers,
+    body: body ? JSON.stringify(body) : void 0
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(
+      `GitHub API error: ${response.status} ${response.statusText}
+${error}`
+    );
+  }
+  return response.json();
+}
+async function githubGraphQL(token, query, variables) {
+  const response = await fetch("https://api.github.com/graphql", {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ query, variables })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(
+      `GitHub GraphQL error: ${response.status} ${response.statusText}
+${error}`
+    );
+  }
+  const result = await response.json();
+  if (result.errors) {
+    throw new Error(
+      `GitHub GraphQL errors: ${result.errors.map((e2) => e2.message).join(", ")}`
+    );
+  }
+  return result.data;
+}
+async function addLabels(context, issueNumber, labels) {
+  await githubRequest(
+    context,
+    "POST",
+    `/repos/${context.owner}/${context.repo}/issues/${issueNumber}/labels`,
+    { labels }
+  );
+}
+async function removeLabel(context, issueNumber, label) {
+  const encodedLabel = encodeURIComponent(label);
+  await githubRequest(
+    context,
+    "DELETE",
+    `/repos/${context.owner}/${context.repo}/issues/${issueNumber}/labels/${encodedLabel}`
+  );
+}
+async function postComment(context, issueNumber, body) {
+  await githubRequest(
+    context,
+    "POST",
+    `/repos/${context.owner}/${context.repo}/issues/${issueNumber}/comments`,
+    { body }
+  );
+}
+async function assignIssue(context, issueNumber, assignees) {
+  await githubRequest(
+    context,
+    "POST",
+    `/repos/${context.owner}/${context.repo}/issues/${issueNumber}/assignees`,
+    { assignees }
+  );
+}
+async function createOrUpdateLabel(context, name, color, description) {
+  try {
+    await githubRequest(
+      context,
+      "PATCH",
+      `/repos/${context.owner}/${context.repo}/labels/${encodeURIComponent(name)}`,
+      { color, description }
+    );
+  } catch (error) {
+    if (error.message.includes("404")) {
+      await githubRequest(
+        context,
+        "POST",
+        `/repos/${context.owner}/${context.repo}/labels`,
+        { name, color, description }
+      );
+    } else {
+      throw error;
+    }
+  }
+}
+async function getIssue(context, issueNumber) {
+  return await githubRequest(
+    context,
+    "GET",
+    `/repos/${context.owner}/${context.repo}/issues/${issueNumber}`
+  );
+}
+async function addIssueToProject(token, projectId, issueId) {
+  const mutation = `
+    mutation($projectId: ID!, $contentId: ID!) {
+      addProjectV2ItemById(input: {
+        projectId: $projectId
+        contentId: $contentId
+      }) {
+        item {
+          id
+        }
+      }
+    }
+  `;
+  const result = await githubGraphQL(token, mutation, {
+    projectId,
+    contentId: issueId
+  });
+  return result.addProjectV2ItemById.item.id;
+}
+async function updateProjectItemStatus(token, projectId, itemId, statusFieldId, statusOptionId) {
+  const mutation = `
+    mutation($projectId: ID!, $itemId: ID!, $fieldId: ID!, $value: ProjectV2FieldValue!) {
+      updateProjectV2ItemFieldValue(input: {
+        projectId: $projectId
+        itemId: $itemId
+        fieldId: $fieldId
+        value: $value
+      }) {
+        projectV2Item {
+          id
+        }
+      }
+    }
+  `;
+  await githubGraphQL(token, mutation, {
+    projectId,
+    itemId,
+    fieldId: statusFieldId,
+    value: {
+      singleSelectOptionId: statusOptionId
+    }
+  });
+}
+async function getIssueNodeId(token, owner, repo, issueNumber) {
+  const query = `
+    query($owner: String!, $repo: String!, $issueNumber: Int!) {
+      repository(owner: $owner, name: $repo) {
+        issue(number: $issueNumber) {
+          id
+        }
+      }
+    }
+  `;
+  const result = await githubGraphQL(token, query, {
+    owner,
+    repo,
+    issueNumber
+  });
+  return result.repository.issue.id;
+}
+async function getProjectItemId(token, projectId, issueId) {
+  const query = `
+    query($projectId: ID!) {
+      node(id: $projectId) {
+        ... on ProjectV2 {
+          items(first: 100) {
+            nodes {
+              id
+              content {
+                ... on Issue {
+                  id
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  `;
+  const result = await githubGraphQL(token, query, {
+    projectId
+  });
+  const item = result.node.items.nodes.find(
+    (node) => node.content.id === issueId
+  );
+  return item ? item.id : null;
+}
+async function moveIssueToStatus(token, owner, repo, issueNumber, config, statusName) {
+  const statusOptionId = config.statusOptions[statusName];
+  if (!statusOptionId) {
+    throw new Error(
+      `Status "${statusName}" not found in project configuration. Available: ${Object.keys(config.statusOptions).join(", ")}`
+    );
+  }
+  console.log(`Moving issue #${issueNumber} to status "${statusName}"...`);
+  const issueId = await getIssueNodeId(token, owner, repo, issueNumber);
+  let itemId = await getProjectItemId(token, config.projectId, issueId);
+  if (!itemId) {
+    console.log("Issue not in project, adding...");
+    itemId = await addIssueToProject(token, config.projectId, issueId);
+  }
+  console.log(`Updating status to "${statusName}"...`);
+  await updateProjectItemStatus(
+    token,
+    config.projectId,
+    itemId,
+    config.statusFieldId,
+    statusOptionId
+  );
+  console.log(`✅ Issue moved to "${statusName}"`);
+}
+async function applyLabels(context, labels) {
+  if (labels.length === 0) {
+    console.log("No labels to apply");
+    return;
+  }
+  try {
+    await addLabels(context, context.issueNumber, labels);
+    console.log(`Applied labels: ${labels.join(", ")}`);
+  } catch (error) {
+    console.error("Error applying labels:", error.message);
+    throw error;
+  }
+}
+async function removeAgentLabel(context, agentType) {
+  const label = `agent: ${agentType}`;
+  try {
+    await removeLabel(context, context.issueNumber, label);
+    console.log(`Removed label: ${label}`);
+  } catch (error) {
+    if (!error.message.includes("404")) {
+      console.error("Error removing label:", error.message);
+    }
+  }
+}
+function getTypeLabel(type) {
+  return `type: ${type}`;
+}
+function getPriorityLabel(priority) {
+  return `priority: ${priority}`;
+}
+function getSizeLabel(size) {
+  return `size: ${size}`;
+}
+function getAgentLabel(agentType) {
+  return `agent: ${agentType}`;
+}
+async function updateProjectStatus(context, statusName) {
+  if (!context.config.projectEnabled) {
+    console.log("Project board integration disabled");
+    return;
+  }
+  if (!context.config.projectId || !context.config.statusFieldId) {
+    console.log("Project configuration missing");
+    return;
+  }
+  if (!context.config.statusOptions || !context.config.statusOptions[statusName]) {
+    console.log(`Status "${statusName}" not configured`);
+    return;
+  }
+  const query = `
+    query($owner: String!, $repo: String!, $number: Int!) {
+      repository(owner: $owner, name: $repo) {
+        issue(number: $number) {
+          projectItems(first: 10) {
+            nodes {
+              id
+            }
+          }
+        }
+      }
+    }
+  `;
+  try {
+    const variables = {
+      owner: context.owner,
+      repo: context.repo,
+      number: context.issueNumber
+    };
+    const result = await githubAPI(context.token, "POST", "/graphql", {
+      query,
+      variables
+    });
+    const itemId = result.data.repository.issue.projectItems.nodes[0]?.id;
+    if (!itemId) {
+      console.log("Issue not in project board, skipping status update");
+      return;
+    }
+    const updateQuery = `
+      mutation($projectId: ID!, $itemId: ID!, $fieldId: ID!, $optionId: String!) {
+        updateProjectV2ItemFieldValue(
+          input: {
+            projectId: $projectId
+            itemId: $itemId
+            fieldId: $fieldId
+            value: { singleSelectOptionId: $optionId }
+          }
+        ) {
+          projectV2Item {
+            id
+          }
+        }
+      }
+    `;
+    const updateVars = {
+      projectId: context.config.projectId,
+      itemId,
+      fieldId: context.config.statusFieldId,
+      optionId: context.config.statusOptions[statusName]
+    };
+    await githubAPI(context.token, "POST", "/graphql", {
+      query: updateQuery,
+      variables: updateVars
+    });
+    console.log(`Updated project status to: ${statusName}`);
+  } catch (error) {
+    console.error("Error updating project status:", error.message);
+  }
+}
+async function triageIssue(context) {
+  console.log(`Triaging issue #${context.issueNumber}: ${context.issueTitle}`);
+  try {
+    await applyLabels(context, [getAgentLabel("triage")]);
+    console.log("Calling AI for analysis...");
+    const analysis = await analyzeIssue(context);
+    console.log("AI Analysis:", JSON.stringify(analysis, null, 2));
+    console.log("Searching for potential duplicates...");
+    const duplicates = await searchDuplicates(context);
+    console.log(`Found ${duplicates.length} potential duplicates`);
+    const labels = [
+      getTypeLabel(analysis.type),
+      getPriorityLabel(analysis.priority),
+      getSizeLabel(analysis.size)
+    ];
+    await applyLabels(context, labels);
+    await postTriageComment(context, analysis, duplicates);
+    await removeAgentLabel(context, "triage");
+    if (context.config.projectEnabled) {
+      console.log("Moving issue to Backlog...");
+      await updateProjectStatus(context, "Backlog");
+    }
+    console.log("✅ Triage complete!");
+    return {
+      success: true,
+      analysis,
+      duplicates
+    };
+  } catch (error) {
+    console.error("❌ Triage failed:", error.message);
+    console.error(error.stack);
+    await postErrorComment(context, error);
+    return {
+      success: false,
+      error: error.message
+    };
+  }
+}
+const index = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  analyzeIssue,
+  applyLabels,
+  getAgentLabel,
+  getPriorityLabel,
+  getSizeLabel,
+  getTypeLabel,
+  postErrorComment,
+  postTriageComment,
+  removeAgentLabel,
+  searchDuplicates,
+  triageIssue,
+  updateProjectStatus
+}, Symbol.toStringTag, { value: "Module" }));
+const PACKAGE_VERSION_INITIALIZED = true;
+export {
+  A as AREA_LABEL_TEMPLATE,
+  L as LABEL_MIGRATIONS,
+  PACKAGE_VERSION_INITIALIZED,
+  S as STANDARD_LABELS,
+  addIssueToProject,
+  addLabels,
+  analyzeIssue,
+  analyzePlanning,
+  e as applyLabels,
+  assignIssue,
+  f as callAnthropic,
+  h as callGitHubModels,
+  i as callOpenAI,
+  completePlanning,
+  createOrUpdateLabel,
+  createProject,
+  createRepository,
+  formatDefinitionOfReady,
+  j as getAICompletion,
+  k as getAgentLabel,
+  l as getAllStandardLabels,
+  getIssue,
+  getIssueNodeId,
+  m as getLabelsByCategory,
+  n as getPriorityLabel,
+  getProjectItemId,
+  o as getSizeLabel,
+  q as getTypeLabel,
+  githubGraphQL,
+  githubRequest,
+  isReady,
+  index as legacy,
+  r as migrateLabel,
+  moveIssueToStatus,
+  t as parseAIJson,
+  postComment,
+  postErrorComment,
+  postPlanComment,
+  postPlanningErrorComment,
+  postReadyCheckComment,
+  postTriageComment,
+  u as removeAgentLabel,
+  removeLabel,
+  searchDuplicates,
+  startPlanning,
+  v as triageIssue,
+  updateProjectItemStatus,
+  w as updateProjectStatus,
+  validateDefinitionOfReady
+};
+//# sourceMappingURL=index.js.map