@happyvertical/github-actions 0.80.0 → 0.80.2

package/dist/src-CezXcNYi.js

@@ -0,0 +1,1318 @@
+import { getProject } from "@happyvertical/projects";
+import { getRepository } from "@happyvertical/repos";
+import https from "node:https";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region src/shared/adapters.ts
+/**
+* Create a repository client from GitHub context
+*/
+async function createRepository(token, owner, repo) {
+	return getRepository({
+		type: "github",
+		owner,
+		repo,
+		token
+	});
+}
+/**
+* Create a project client from configuration
+*/
+async function createProject(token, projectId, statusFieldId, statusOptions) {
+	return getProject({
+		type: "github",
+		projectId,
+		token,
+		statusFieldId,
+		statusOptions
+	});
+}
+//#endregion
+//#region src/planning/analyze.ts
+/**
+* Generate an AI-powered implementation plan for a GitHub issue.
+*
+* Builds a prompt from the issue context and repository description, then
+* calls the AI service to produce a structured plan with tasks, complexity,
+* and technical considerations.
+*
+* @param context - Planning context with issue details and repository config
+* @returns Structured implementation plan
+*/
+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: []
+	};
+}
+//#endregion
+//#region src/planning/definition-of-ready.ts
+/**
+* Check if an issue meets the Definition of Ready criteria
+*/
+function validateDefinitionOfReady(issue, hasPlanComment) {
+	const labels = issue.labels.map((l) => typeof l === "string" ? l : l.name);
+	return {
+		hasClearDescription: !!issue.body && issue.body.trim().length > 50,
+		hasTypeLabel: labels.some((l) => l.startsWith("type:")),
+		hasPriorityLabel: labels.some((l) => l.startsWith("priority:")),
+		hasSizeLabel: labels.some((l) => l.startsWith("size:")),
+		hasPlan: hasPlanComment,
+		noBlockers: !labels.some((l) => l === "status: blocked")
+	};
+}
+/**
+* Check if issue is ready (all criteria met)
+*/
+function isReady(dor) {
+	return dor.hasClearDescription && dor.hasTypeLabel && dor.hasPriorityLabel && dor.hasSizeLabel && dor.hasPlan && dor.noBlockers;
+}
+/**
+* Format Definition of Ready as markdown checklist
+*/
+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.**"}`;
+}
+//#endregion
+//#region src/planning/comment.ts
+/**
+* Post implementation plan comment
+*/
+async function postPlanComment(repo, issueNumber, plan) {
+	const comment = `## 🤖 Implementation Plan
+
+### Summary
+${plan.summary}
+
+### Tasks
+${plan.tasks.map((task, i) => `${i + 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\n${plan.affected_files.map((f) => `- \`${f}\``).join("\n")}` : ""}
+
+${plan.dependencies && plan.dependencies.length > 0 ? `### Dependencies\n${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);
+}
+/**
+* Post Definition of Ready status comment
+*/
+async function postReadyCheckComment(repo, issueNumber, dor) {
+	const comment = formatDefinitionOfReady(dor);
+	await repo.addComment(issueNumber, comment);
+}
+/**
+* Post planning error 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);
+}
+//#endregion
+//#region src/planning/index.ts
+/**
+* Planning Workflow Orchestration
+*/
+/**
+* Start planning workflow for an issue
+*/
+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 {
+			await postPlanningErrorComment(await createRepository(context.token, context.owner, context.repo), context.issueNumber, error);
+		} catch {}
+		return {
+			success: false,
+			error: error.message
+		};
+	}
+}
+/**
+* Complete planning workflow and move to Ready
+*/
+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 dor = validateDefinitionOfReady(issue, (await repo.listComments(context.issueNumber)).some((c) => c.body?.includes("Implementation Plan")));
+		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 itemId = (await project.listItems()).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
+		};
+	}
+}
+//#endregion
+//#region src/shared/ai.ts
+/**
+* Call GitHub Models API (available to all GitHub users)
+*/
+async function callGitHubModels(token, messages, options = {}) {
+	const model = options.model || "gpt-4o-mini";
+	const temperature = options.temperature ?? .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}\n${error}`);
+	}
+	return (await response.json()).choices[0].message.content;
+}
+/**
+* Call OpenAI API directly
+*/
+async function callOpenAI(apiKey, messages, options = {}) {
+	const model = options.model || "gpt-4o-mini";
+	const temperature = options.temperature ?? .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}\n${error}`);
+	}
+	return (await response.json()).choices[0].message.content;
+}
+/**
+* Call Anthropic Claude API
+*/
+async function callAnthropic(apiKey, messages, options = {}) {
+	const model = options.model || "claude-3-5-sonnet-20241022";
+	const temperature = options.temperature ?? .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}\n${error}`);
+	}
+	return (await response.json()).content[0].text;
+}
+/**
+* Unified AI completion function
+*
+* Automatically selects provider based on available environment variables:
+* - GITHUB_TOKEN → GitHub Models (default)
+* - OPENAI_API_KEY → OpenAI
+* - ANTHROPIC_API_KEY → Anthropic
+*/
+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.");
+}
+/**
+* Parse JSON from AI response
+*
+* Handles markdown code blocks and extracts JSON
+*/
+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}\n\nResponse: ${response}`);
+	}
+}
+//#endregion
+//#region src/shared/github.ts
+/**
+* Make a GitHub REST API request
+*/
+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}\n${error}`);
+	}
+	return response.json();
+}
+/**
+* Make a GitHub GraphQL API request
+*/
+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}\n${error}`);
+	}
+	const result = await response.json();
+	if (result.errors) throw new Error(`GitHub GraphQL errors: ${result.errors.map((e) => e.message).join(", ")}`);
+	return result.data;
+}
+/**
+* Add labels to an issue
+*/
+async function addLabels(context, issueNumber, labels) {
+	await githubRequest(context, "POST", `/repos/${context.owner}/${context.repo}/issues/${issueNumber}/labels`, { labels });
+}
+/**
+* Remove a label from an issue
+*/
+async function removeLabel(context, issueNumber, label) {
+	const encodedLabel = encodeURIComponent(label);
+	await githubRequest(context, "DELETE", `/repos/${context.owner}/${context.repo}/issues/${issueNumber}/labels/${encodedLabel}`);
+}
+/**
+* Post a comment on an issue
+*/
+async function postComment(context, issueNumber, body) {
+	await githubRequest(context, "POST", `/repos/${context.owner}/${context.repo}/issues/${issueNumber}/comments`, { body });
+}
+/**
+* Assign users to an issue
+*/
+async function assignIssue(context, issueNumber, assignees) {
+	await githubRequest(context, "POST", `/repos/${context.owner}/${context.repo}/issues/${issueNumber}/assignees`, { assignees });
+}
+/**
+* Create or update a repository label
+*/
+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;
+	}
+}
+/**
+* Get issue details
+*/
+async function getIssue(context, issueNumber) {
+	return await githubRequest(context, "GET", `/repos/${context.owner}/${context.repo}/issues/${issueNumber}`);
+}
+//#endregion
+//#region src/shared/labels.ts
+/**
+* Standard label set organized by category
+*/
+var 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"
+		}
+	]
+};
+/**
+* Area labels are repository-specific, so we provide a template
+*/
+var 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"
+	}
+];
+/**
+* Get all standard labels as a flat array
+*/
+function getAllStandardLabels() {
+	return Object.values(STANDARD_LABELS).flat();
+}
+/**
+* Get labels by category
+*/
+function getLabelsByCategory(category) {
+	return STANDARD_LABELS[category] || [];
+}
+/**
+* Map old label names to new standard names
+*/
+var LABEL_MIGRATIONS = {
+	bug: "type: bug",
+	feature: "type: feature",
+	enhancement: "type: feature",
+	documentation: "type: docs",
+	question: "type: question",
+	"tech-debt": "type: maintenance",
+	epic: "type: feature"
+};
+/**
+* Migrate old label to new standard label
+*/
+function migrateLabel(oldLabel) {
+	return LABEL_MIGRATIONS[oldLabel] || oldLabel;
+}
+//#endregion
+//#region src/shared/projects.ts
+/**
+* GitHub Projects V2 API Utilities
+*
+* Handles interaction with GitHub Projects V2 via GraphQL API.
+*/
+/**
+* Add an issue to a project
+*/
+async function addIssueToProject(token, projectId, issueId) {
+	return (await githubGraphQL(token, `
+    mutation($projectId: ID!, $contentId: ID!) {
+      addProjectV2ItemById(input: {
+        projectId: $projectId
+        contentId: $contentId
+      }) {
+        item {
+          id
+        }
+      }
+    }
+  `, {
+		projectId,
+		contentId: issueId
+	})).addProjectV2ItemById.item.id;
+}
+/**
+* Update project item status
+*/
+async function updateProjectItemStatus(token, projectId, itemId, statusFieldId, statusOptionId) {
+	await githubGraphQL(token, `
+    mutation($projectId: ID!, $itemId: ID!, $fieldId: ID!, $value: ProjectV2FieldValue!) {
+      updateProjectV2ItemFieldValue(input: {
+        projectId: $projectId
+        itemId: $itemId
+        fieldId: $fieldId
+        value: $value
+      }) {
+        projectV2Item {
+          id
+        }
+      }
+    }
+  `, {
+		projectId,
+		itemId,
+		fieldId: statusFieldId,
+		value: { singleSelectOptionId: statusOptionId }
+	});
+}
+/**
+* Get issue's node ID (required for adding to project)
+*/
+async function getIssueNodeId(token, owner, repo, issueNumber) {
+	return (await githubGraphQL(token, `
+    query($owner: String!, $repo: String!, $issueNumber: Int!) {
+      repository(owner: $owner, name: $repo) {
+        issue(number: $issueNumber) {
+          id
+        }
+      }
+    }
+  `, {
+		owner,
+		repo,
+		issueNumber
+	})).repository.issue.id;
+}
+/**
+* Get project item ID for an issue (if it exists in the project)
+*/
+async function getProjectItemId(token, projectId, issueId) {
+	const item = (await githubGraphQL(token, `
+    query($projectId: ID!) {
+      node(id: $projectId) {
+        ... on ProjectV2 {
+          items(first: 100) {
+            nodes {
+              id
+              content {
+                ... on Issue {
+                  id
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  `, { projectId })).node.items.nodes.find((node) => node.content.id === issueId);
+	return item ? item.id : null;
+}
+/**
+* Move issue to a specific status in the project
+*/
+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}"`);
+}
+//#endregion
+//#region src/triage/analyze.ts
+/**
+* GitHub Models AI Analysis
+*/
+var VALID_TYPES = [
+	"bug",
+	"feature",
+	"docs",
+	"maintenance",
+	"research",
+	"question"
+];
+var VALID_PRIORITIES = [
+	"critical",
+	"high",
+	"medium",
+	"low",
+	"icebox"
+];
+var 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 }
+	};
+}
+/**
+* Analyze a GitHub issue using AI to determine type, priority, size, and affected packages.
+*
+* Sends the issue details to the configured AI provider and validates the structured response.
+*
+* @param context - Triage context with issue details and repository config
+* @returns Validated AI analysis with type, priority, size, and reasoning
+* @throws If the AI response cannot be parsed or fails validation
+*/
+async function analyzeIssue(context) {
+	return validateAIAnalysis(parseAIJson(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: buildAnalysisPrompt(context)
+	}])));
+}
+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;
+}
+//#endregion
+//#region src/triage/github.ts
+/**
+* GitHub API Helper Functions
+*/
+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(/* @__PURE__ */ new Error(`GitHub API error: ${res.statusCode} ${body}`));
+			});
+		});
+		req.on("error", reject);
+		if (data) req.write(JSON.stringify(data));
+		req.end();
+	});
+}
+//#endregion
+//#region src/triage/comment.ts
+/**
+* Issue Comment Posting
+*/
+/**
+* Post a structured triage comment on the issue with AI analysis results and duplicate links.
+*
+* @param context - Triage context with repo info and issue number
+* @param analysis - AI analysis results (type, priority, size, reasoning)
+* @param duplicates - Array of potential duplicate issues to include in the comment
+*/
+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;
+	}
+}
+/**
+* Post a comment indicating that automated triage failed, prompting manual triage.
+*
+* @param context - Triage context with repo info and issue number
+* @param error - The error that caused triage to fail
+*/
+async function postErrorComment(context, error) {
+	const comment = `## 🤖 AI Triage Failed\n\nAutomated triage encountered an error:\n\`\`\`\n${error.message}\n\`\`\`\n\nPlease 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\n\n`;
+	comment += `**Type**: \`${analysis.type}\`\n`;
+	comment += `**Priority**: \`${analysis.priority}\`\n`;
+	comment += `**Size**: \`${analysis.size}\`\n\n`;
+	if (analysis.affected_packages && analysis.affected_packages.length > 0) {
+		const packages = analysis.affected_packages.map((p) => `\`${p}\``).join(", ");
+		comment += `**Affected Packages**: ${packages}\n\n`;
+	}
+	comment += `**Analysis**: ${analysis.reasoning}\n\n`;
+	if (duplicates.length > 0) {
+		comment += `### ⚠️ Potential Duplicates\n\n`;
+		duplicates.forEach((dup) => {
+			comment += `- #${dup.number}: ${dup.title}\n`;
+		});
+		comment += `\n`;
+	}
+	comment += `---\n`;
+	comment += `*This triage was performed automatically using GitHub Models API. Please review and adjust labels as needed.*`;
+	return comment;
+}
+//#endregion
+//#region src/triage/duplicates.ts
+/**
+* Duplicate Issue Detection
+*/
+/**
+* Search for potential duplicate issues using GitHub Search API.
+*
+* Extracts keywords from the issue title and searches the repository for similar issues.
+* The current issue is excluded from results.
+*
+* @param context - Triage context with issue details and repo info
+* @returns Array of potentially duplicate issues (up to 4)
+*/
+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 {
+		return (await githubAPI(context.token, "GET", path, null)).items.filter((issue) => issue.number !== context.issueNumber);
+	} catch (error) {
+		console.error("Error searching for duplicates:", error.message);
+		return [];
+	}
+}
+//#endregion
+//#region src/triage/label.ts
+/**
+* Issue Labeling
+*/
+/**
+* Apply labels to an issue using the raw GitHub API.
+* @deprecated Use the v2 export which uses `@happyvertical/repos`.
+*/
+async function applyLabels$1(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;
+	}
+}
+/**
+* Remove an `agent: <type>` label from an issue. Silently ignores 404 errors.
+* @deprecated Use the v2 export which uses `@happyvertical/repos`.
+*/
+async function removeAgentLabel$1(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$1(type) {
+	return `type: ${type}`;
+}
+function getPriorityLabel$1(priority) {
+	return `priority: ${priority}`;
+}
+function getSizeLabel$1(size) {
+	return `size: ${size}`;
+}
+function getAgentLabel$1(agentType) {
+	return `agent: ${agentType}`;
+}
+//#endregion
+//#region src/triage/project.ts
+/**
+* GitHub Project Board Management
+*/
+/**
+* Update an issue's status on the GitHub Projects V2 board via raw GraphQL.
+* @deprecated Use the v2 export which uses `@happyvertical/projects`.
+*/
+async function updateProjectStatus$1(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 itemId = (await githubAPI(context.token, "POST", "/graphql", {
+			query,
+			variables
+		})).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);
+	}
+}
+//#endregion
+//#region src/triage/index.ts
+/**
+* Issue Triage Orchestration
+*/
+var triage_exports = /* @__PURE__ */ __exportAll({
+	analyzeIssue: () => analyzeIssue,
+	applyLabels: () => applyLabels$1,
+	getAgentLabel: () => getAgentLabel$1,
+	getPriorityLabel: () => getPriorityLabel$1,
+	getSizeLabel: () => getSizeLabel$1,
+	getTypeLabel: () => getTypeLabel$1,
+	postErrorComment: () => postErrorComment,
+	postTriageComment: () => postTriageComment,
+	removeAgentLabel: () => removeAgentLabel$1,
+	searchDuplicates: () => searchDuplicates,
+	triageIssue: () => triageIssue$1,
+	updateProjectStatus: () => updateProjectStatus$1
+});
+/**
+* @deprecated Use the default export from `@happyvertical/github-actions` instead.
+* Legacy triage orchestrator using raw GitHub API calls.
+*/
+async function triageIssue$1(context) {
+	console.log(`Triaging issue #${context.issueNumber}: ${context.issueTitle}`);
+	try {
+		await applyLabels$1(context, [getAgentLabel$1("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`);
+		await applyLabels$1(context, [
+			getTypeLabel$1(analysis.type),
+			getPriorityLabel$1(analysis.priority),
+			getSizeLabel$1(analysis.size)
+		]);
+		await postTriageComment(context, analysis, duplicates);
+		await removeAgentLabel$1(context, "triage");
+		if (context.config.projectEnabled) {
+			console.log("Moving issue to Backlog...");
+			await updateProjectStatus$1(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
+		};
+	}
+}
+//#endregion
+//#region src/triage/label-v2.ts
+/**
+* Issue Labeling (Refactored to use @happyvertical/repos)
+*/
+/**
+* Apply labels to an issue using `@happyvertical/repos`.
+*
+* @param context - Triage context with token and repo info
+* @param labels - Label names to apply
+*/
+async function applyLabels(context, labels) {
+	if (labels.length === 0) {
+		console.log("No labels to apply");
+		return;
+	}
+	try {
+		await (await createRepository(context.token, context.owner, context.repo)).addLabels(context.issueNumber, labels);
+		console.log(`Applied labels: ${labels.join(", ")}`);
+	} catch (error) {
+		console.error("Error applying labels:", error.message);
+		throw error;
+	}
+}
+/**
+* Remove an `agent: <type>` label from an issue. Silently ignores 404 errors.
+*
+* @param context - Triage context with token and repo info
+* @param agentType - Agent type suffix (e.g., "triage", "planning")
+*/
+async function removeAgentLabel(context, agentType) {
+	const label = `agent: ${agentType}`;
+	try {
+		await (await createRepository(context.token, context.owner, context.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}`;
+}
+//#endregion
+//#region src/triage/project-v2.ts
+/**
+* GitHub Project Board Management (Refactored to use @happyvertical/projects)
+*/
+/**
+* Update an issue's status on the GitHub Projects V2 board using `@happyvertical/projects`.
+*
+* Adds the issue to the project if not already present, then sets the status field.
+* No-ops if project integration is disabled or the status name is not configured.
+*
+* @param context - Triage context with project config
+* @param statusName - Target status name (must exist in `config.statusOptions`)
+*/
+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);
+		let itemId = (await project.listItems()).find((item) => item.contentId === issue.id)?.id;
+		if (!itemId) {
+			console.log("Issue not in project, adding...");
+			itemId = (await project.addItem(issue.id)).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;
+	}
+}
+//#endregion
+//#region src/triage/index-v2.ts
+/**
+* Issue Triage Orchestration (Refactored to use @happyvertical/repos and @happyvertical/projects)
+*/
+/**
+* Run the full issue triage workflow using `@happyvertical/repos`.
+*
+* Applies an agent label, runs AI analysis, searches for duplicates,
+* applies type/priority/size labels, posts a triage comment, and
+* optionally updates the project board status.
+*
+* @param context - Triage context including token, repo info, issue details, and config
+* @returns Result indicating success/failure with analysis and duplicate data
+*/
+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`);
+		await applyLabels(context, [
+			getTypeLabel(analysis.type),
+			getPriorityLabel(analysis.priority),
+			getSizeLabel(analysis.size)
+		]);
+		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
+		};
+	}
+}
+//#endregion
+//#region src/index.ts
+/** @internal */
+var PACKAGE_VERSION_INITIALIZED = true;
+//#endregion
+export { githubGraphQL as A, startPlanning as B, getAllStandardLabels as C, assignIssue as D, addLabels as E, callGitHubModels as F, isReady as G, postPlanningErrorComment as H, callOpenAI as I, createProject as J, validateDefinitionOfReady as K, getAICompletion as L, postComment as M, removeLabel as N, createOrUpdateLabel as O, callAnthropic as P, parseAIJson as R, STANDARD_LABELS as S, migrateLabel as T, postReadyCheckComment as U, postPlanComment as V, formatDefinitionOfReady as W, createRepository as Y, getProjectItemId as _, getAgentLabel as a, AREA_LABEL_TEMPLATE as b, getTypeLabel as c, searchDuplicates as d, postErrorComment as f, getIssueNodeId as g, addIssueToProject as h, applyLabels as i, githubRequest as j, getIssue as k, removeAgentLabel as l, analyzeIssue as m, triageIssue as n, getPriorityLabel as o, postTriageComment as p, analyzePlanning as q, updateProjectStatus as r, getSizeLabel as s, PACKAGE_VERSION_INITIALIZED as t, triage_exports as u, moveIssueToStatus as v, getLabelsByCategory as w, LABEL_MIGRATIONS as x, updateProjectItemStatus as y, completePlanning as z };
+
+//# sourceMappingURL=src-CezXcNYi.js.map