@happyvertical/github-actions 0.74.8

package/dist/index-v2-CqFKwTm8.js

@@ -0,0 +1,687 @@
+import https from "node:https";
+import { getProject } from "@happyvertical/projects";
+import { getRepository } from "@happyvertical/repos";
+async function createRepository(token, owner, repo) {
+  return getRepository({
+    type: "github",
+    owner,
+    repo,
+    token
+  });
+}
+async function createProject(token, projectId, statusFieldId, statusOptions) {
+  return getProject({
+    type: "github",
+    projectId,
+    token,
+    statusFieldId,
+    statusOptions
+  });
+}
+async function callGitHubModels(token, messages, options = {}) {
+  const model = options.model || "gpt-4o-mini";
+  const temperature = options.temperature ?? 0.3;
+  const maxTokens = options.maxTokens ?? 1e3;
+  const response = await fetch(
+    `https://models.inference.ai.azure.com/chat/completions`,
+    {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        model,
+        messages,
+        temperature,
+        max_tokens: maxTokens
+      })
+    }
+  );
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(
+      `GitHub Models API error: ${response.status} ${response.statusText}
+${error}`
+    );
+  }
+  const result = await response.json();
+  return result.choices[0].message.content;
+}
+async function callOpenAI(apiKey, messages, options = {}) {
+  const model = options.model || "gpt-4o-mini";
+  const temperature = options.temperature ?? 0.3;
+  const maxTokens = options.maxTokens ?? 1e3;
+  const response = await fetch("https://api.openai.com/v1/chat/completions", {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      model,
+      messages,
+      temperature,
+      max_tokens: maxTokens
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(
+      `OpenAI API error: ${response.status} ${response.statusText}
+${error}`
+    );
+  }
+  const result = await response.json();
+  return result.choices[0].message.content;
+}
+async function callAnthropic(apiKey, messages, options = {}) {
+  const model = options.model || "claude-3-5-sonnet-20241022";
+  const temperature = options.temperature ?? 0.3;
+  const maxTokens = options.maxTokens ?? 1e3;
+  const systemMessage = messages.find((m) => m.role === "system");
+  const conversationMessages = messages.filter((m) => m.role !== "system");
+  const response = await fetch("https://api.anthropic.com/v1/messages", {
+    method: "POST",
+    headers: {
+      "x-api-key": apiKey,
+      "anthropic-version": "2023-06-01",
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      model,
+      max_tokens: maxTokens,
+      temperature,
+      system: systemMessage?.content,
+      messages: conversationMessages
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(
+      `Anthropic API error: ${response.status} ${response.statusText}
+${error}`
+    );
+  }
+  const result = await response.json();
+  return result.content[0].text;
+}
+async function getAICompletion(messages, options = {}) {
+  if (process.env.GITHUB_TOKEN) {
+    return callGitHubModels(process.env.GITHUB_TOKEN, messages, options);
+  }
+  if (process.env.OPENAI_API_KEY) {
+    return callOpenAI(process.env.OPENAI_API_KEY, messages, options);
+  }
+  if (process.env.ANTHROPIC_API_KEY) {
+    return callAnthropic(process.env.ANTHROPIC_API_KEY, messages, options);
+  }
+  throw new Error(
+    "No AI API credentials found. Set GITHUB_TOKEN, OPENAI_API_KEY, or ANTHROPIC_API_KEY environment variable."
+  );
+}
+function parseAIJson(response) {
+  let cleaned = response.trim();
+  if (cleaned.startsWith("```json")) {
+    cleaned = cleaned.slice(7);
+  } else if (cleaned.startsWith("```")) {
+    cleaned = cleaned.slice(3);
+  }
+  if (cleaned.endsWith("```")) {
+    cleaned = cleaned.slice(0, -3);
+  }
+  cleaned = cleaned.trim();
+  try {
+    return JSON.parse(cleaned);
+  } catch (error) {
+    throw new Error(
+      `Failed to parse AI response as JSON: ${error.message}
+
+Response: ${response}`
+    );
+  }
+}
+const STANDARD_LABELS = {
+  type: [
+    {
+      name: "type: bug",
+      color: "d73a4a",
+      description: "Something isn't working"
+    },
+    {
+      name: "type: feature",
+      color: "0075ca",
+      description: "New feature or enhancement"
+    },
+    {
+      name: "type: docs",
+      color: "0075ca",
+      description: "Documentation improvements"
+    },
+    {
+      name: "type: maintenance",
+      color: "6c757d",
+      description: "Maintenance and refactoring"
+    },
+    {
+      name: "type: research",
+      color: "a371f7",
+      description: "Research and investigation"
+    },
+    {
+      name: "type: question",
+      color: "d876e3",
+      description: "Question or discussion"
+    }
+  ],
+  priority: [
+    {
+      name: "priority: critical",
+      color: "b60205",
+      description: "Critical priority, needs immediate attention"
+    },
+    {
+      name: "priority: high",
+      color: "d93f0b",
+      description: "High priority"
+    },
+    {
+      name: "priority: medium",
+      color: "fbca04",
+      description: "Medium priority (default)"
+    },
+    {
+      name: "priority: low",
+      color: "fef2c0",
+      description: "Low priority"
+    },
+    {
+      name: "priority: icebox",
+      color: "e1e4e8",
+      description: "Future consideration, keep in Backlog"
+    }
+  ],
+  size: [
+    {
+      name: "size: xs",
+      color: "c2e0c6",
+      description: "Extra small (< 2 hours)"
+    },
+    {
+      name: "size: s",
+      color: "7bd88f",
+      description: "Small (2-4 hours)"
+    },
+    {
+      name: "size: m",
+      color: "3fb950",
+      description: "Medium (~1 day)"
+    },
+    {
+      name: "size: l",
+      color: "2ea043",
+      description: "Large (2-3 days)"
+    },
+    {
+      name: "size: xl",
+      color: "1a7f37",
+      description: "Extra large (> 3 days)"
+    }
+  ],
+  status: [
+    {
+      name: "status: blocked",
+      color: "d73a4a",
+      description: "Blocked by external dependency"
+    },
+    {
+      name: "status: help-wanted",
+      color: "008672",
+      description: "Community contributions welcome"
+    },
+    {
+      name: "status: good-first-issue",
+      color: "7057ff",
+      description: "Good for newcomers"
+    }
+  ]
+};
+const AREA_LABEL_TEMPLATE = [
+  {
+    name: "area: core",
+    color: "fbca04",
+    description: "Core functionality"
+  },
+  {
+    name: "area: api",
+    color: "fbca04",
+    description: "API-related"
+  },
+  {
+    name: "area: ui",
+    color: "fbca04",
+    description: "User interface"
+  },
+  {
+    name: "area: cli",
+    color: "fbca04",
+    description: "Command-line interface"
+  },
+  {
+    name: "area: docs",
+    color: "fbca04",
+    description: "Documentation"
+  },
+  {
+    name: "area: infra",
+    color: "fbca04",
+    description: "Infrastructure and deployment"
+  },
+  {
+    name: "area: tests",
+    color: "fbca04",
+    description: "Testing infrastructure"
+  }
+];
+function getAllStandardLabels() {
+  return Object.values(STANDARD_LABELS).flat();
+}
+function getLabelsByCategory(category) {
+  return STANDARD_LABELS[category] || [];
+}
+const LABEL_MIGRATIONS = {
+  bug: "type: bug",
+  feature: "type: feature",
+  enhancement: "type: feature",
+  documentation: "type: docs",
+  question: "type: question",
+  "tech-debt": "type: maintenance",
+  epic: "type: feature"
+};
+function migrateLabel(oldLabel) {
+  return LABEL_MIGRATIONS[oldLabel] || oldLabel;
+}
+const VALID_TYPES = [
+  "bug",
+  "feature",
+  "docs",
+  "maintenance",
+  "research",
+  "question"
+];
+const VALID_PRIORITIES = [
+  "critical",
+  "high",
+  "medium",
+  "low",
+  "icebox"
+];
+const VALID_SIZES = ["xs", "s", "m", "l", "xl"];
+function validateAIAnalysis(parsed) {
+  if (!parsed || typeof parsed !== "object") {
+    throw new Error("AI response is not a valid object");
+  }
+  const response = parsed;
+  if (!response.type || typeof response.type !== "string") {
+    throw new Error("AI response missing required field: type");
+  }
+  if (!response.priority || typeof response.priority !== "string") {
+    throw new Error("AI response missing required field: priority");
+  }
+  if (!response.size || typeof response.size !== "string") {
+    throw new Error("AI response missing required field: size");
+  }
+  if (!response.reasoning || typeof response.reasoning !== "string") {
+    throw new Error("AI response missing required field: reasoning");
+  }
+  if (!VALID_TYPES.includes(response.type)) {
+    throw new Error(`Invalid type: ${response.type}`);
+  }
+  if (!VALID_PRIORITIES.includes(response.priority)) {
+    throw new Error(`Invalid priority: ${response.priority}`);
+  }
+  if (!VALID_SIZES.includes(response.size)) {
+    throw new Error(`Invalid size: ${response.size}`);
+  }
+  if (response.affected_packages !== void 0) {
+    if (!Array.isArray(response.affected_packages)) {
+      throw new Error("affected_packages must be an array");
+    }
+    if (!response.affected_packages.every((pkg) => typeof pkg === "string")) {
+      throw new Error("affected_packages must contain only strings");
+    }
+  }
+  return {
+    type: response.type,
+    priority: response.priority,
+    size: response.size,
+    reasoning: response.reasoning,
+    ...response.affected_packages && {
+      affected_packages: response.affected_packages
+    }
+  };
+}
+async function analyzeIssue(context) {
+  const prompt = buildAnalysisPrompt(context);
+  const response = await getAICompletion([
+    {
+      role: "system",
+      content: "You are an expert GitHub issue triager. Analyze issues and provide structured triage information in JSON format."
+    },
+    {
+      role: "user",
+      content: prompt
+    }
+  ]);
+  const parsed = parseAIJson(response);
+  return validateAIAnalysis(parsed);
+}
+function buildAnalysisPrompt(context) {
+  const { config, issueNumber, issueTitle, issueBody, issueAuthor } = context;
+  let prompt = `Analyze this GitHub issue and provide triage information for our kanban workflow.
+
+Repository: ${context.owner}/${context.repo} (${config.repoDescription})
+
+Issue #${issueNumber}
+Title: ${issueTitle}
+Body: ${issueBody || "(empty)"}
+Author: ${issueAuthor}
+
+Determine:
+1. **type**: One of: bug, feature, docs, maintenance, research, question
+2. **priority**: critical, high, medium, low, icebox
+   - Use "icebox" for low priority or future consideration items
+3. **size**: Estimated effort: xs (<2hr), s (2-4hr), m (~1day), l (2-3days), xl (>3days)`;
+  if (config.packagePattern) {
+    prompt += `
+4. **affected_packages**: List of ${config.packagePattern} packages affected`;
+    if (config.packageExamples && config.packageExamples.length > 0) {
+      prompt += ` (e.g., ${JSON.stringify(config.packageExamples)})`;
+    }
+    prompt += `
+5. **reasoning**: Brief explanation of your analysis (2-3 sentences)`;
+  } else {
+    prompt += `
+4. **reasoning**: Brief explanation of your analysis (2-3 sentences)`;
+  }
+  prompt += `
+
+Return JSON in this exact format:
+{
+  "type": "bug|feature|docs|maintenance|research|question",
+  "priority": "critical|high|medium|low|icebox",
+  "size": "xs|s|m|l|xl",`;
+  if (config.packagePattern) {
+    prompt += `
+  "affected_packages": ["package names"],`;
+  }
+  prompt += `
+  "reasoning": "explanation here"
+}`;
+  return prompt;
+}
+async function githubAPI(token, method, path, data = null) {
+  return new Promise((resolve, reject) => {
+    const options = {
+      hostname: "api.github.com",
+      path,
+      method,
+      headers: {
+        Authorization: `token ${token}`,
+        Accept: "application/vnd.github+json",
+        "User-Agent": "happyvertical-github-actions",
+        "X-GitHub-Api-Version": "2022-11-28"
+      }
+    };
+    if (data) {
+      options.headers = {
+        ...options.headers,
+        "Content-Type": "application/json"
+      };
+    }
+    const req = https.request(options, (res) => {
+      let body = "";
+      res.on("data", (chunk) => body += chunk);
+      res.on("end", () => {
+        if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+          resolve(body ? JSON.parse(body) : null);
+        } else {
+          reject(new Error(`GitHub API error: ${res.statusCode} ${body}`));
+        }
+      });
+    });
+    req.on("error", reject);
+    if (data) req.write(JSON.stringify(data));
+    req.end();
+  });
+}
+async function postTriageComment(context, analysis, duplicates) {
+  const comment = buildTriageComment(context, analysis, duplicates);
+  const path = `/repos/${context.owner}/${context.repo}/issues/${context.issueNumber}/comments`;
+  try {
+    await githubAPI(context.token, "POST", path, { body: comment });
+    console.log("Posted triage comment");
+  } catch (error) {
+    console.error("Error posting comment:", error.message);
+    throw error;
+  }
+}
+async function postErrorComment(context, error) {
+  const comment = `## 🤖 AI Triage Failed
+
+Automated triage encountered an error:
+\`\`\`
+${error.message}
+\`\`\`
+
+Please triage this issue manually.`;
+  const path = `/repos/${context.owner}/${context.repo}/issues/${context.issueNumber}/comments`;
+  try {
+    await githubAPI(context.token, "POST", path, { body: comment });
+  } catch (err) {
+    console.error("Error posting error comment:", err.message);
+  }
+}
+function buildTriageComment(context, analysis, duplicates) {
+  let comment = `## 🤖 AI Triage
+
+`;
+  comment += `**Type**: \`${analysis.type}\`
+`;
+  comment += `**Priority**: \`${analysis.priority}\`
+`;
+  comment += `**Size**: \`${analysis.size}\`
+
+`;
+  if (analysis.affected_packages && analysis.affected_packages.length > 0) {
+    const packages = analysis.affected_packages.map((p) => `\`${p}\``).join(", ");
+    comment += `**Affected Packages**: ${packages}
+
+`;
+  }
+  comment += `**Analysis**: ${analysis.reasoning}
+
+`;
+  if (duplicates.length > 0) {
+    comment += `### ⚠️ Potential Duplicates
+
+`;
+    duplicates.forEach((dup) => {
+      comment += `- #${dup.number}: ${dup.title}
+`;
+    });
+    comment += `
+`;
+  }
+  comment += `---
+`;
+  comment += `*This triage was performed automatically using GitHub Models API. Please review and adjust labels as needed.*`;
+  return comment;
+}
+async function searchDuplicates(context) {
+  const keywords = context.issueTitle.split(" ").slice(0, 5).join(" ");
+  const query = `repo:${context.owner}/${context.repo} is:issue ${keywords}`;
+  const path = `/search/issues?q=${encodeURIComponent(query)}&per_page=5`;
+  try {
+    const result = await githubAPI(context.token, "GET", path, null);
+    return result.items.filter((issue) => issue.number !== context.issueNumber);
+  } catch (error) {
+    console.error("Error searching for duplicates:", error.message);
+    return [];
+  }
+}
+async function applyLabels(context, labels) {
+  if (labels.length === 0) {
+    console.log("No labels to apply");
+    return;
+  }
+  try {
+    const repo = await createRepository(
+      context.token,
+      context.owner,
+      context.repo
+    );
+    await repo.addLabels(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 {
+    const repo = await createRepository(
+      context.token,
+      context.owner,
+      context.repo
+    );
+    await repo.removeLabel(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;
+  }
+  try {
+    const repo = await createRepository(
+      context.token,
+      context.owner,
+      context.repo
+    );
+    const project = await createProject(
+      context.token,
+      context.config.projectId,
+      context.config.statusFieldId,
+      context.config.statusOptions
+    );
+    const issue = await repo.getIssue(context.issueNumber);
+    const items = await project.listItems();
+    let itemId = items.find(
+      (item) => item.contentId === issue.id
+    )?.id;
+    if (!itemId) {
+      console.log("Issue not in project, adding...");
+      const item = await project.addItem(issue.id);
+      itemId = item.id;
+    }
+    await project.updateItemStatus(itemId, statusName);
+    console.log(`Updated project status to: ${statusName}`);
+  } catch (error) {
+    console.error("Error updating project status:", error.message);
+    throw error;
+  }
+}
+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
+    };
+  }
+}
+export {
+  AREA_LABEL_TEMPLATE as A,
+  LABEL_MIGRATIONS as L,
+  STANDARD_LABELS as S,
+  createProject as a,
+  analyzeIssue as b,
+  createRepository as c,
+  postErrorComment as d,
+  applyLabels as e,
+  callAnthropic as f,
+  githubAPI as g,
+  callGitHubModels as h,
+  callOpenAI as i,
+  getAICompletion as j,
+  getAgentLabel as k,
+  getAllStandardLabels as l,
+  getLabelsByCategory as m,
+  getPriorityLabel as n,
+  getSizeLabel as o,
+  postTriageComment as p,
+  getTypeLabel as q,
+  migrateLabel as r,
+  searchDuplicates as s,
+  parseAIJson as t,
+  removeAgentLabel as u,
+  triageIssue as v,
+  updateProjectStatus as w
+};
+//# sourceMappingURL=index-v2-CqFKwTm8.js.map