@etus/bhono-app 0.1.1

package/templates/base/.claude/skills/linear/scripts/issues/get.ts

@@ -0,0 +1,68 @@
+import { client } from "../../lib/client.js";
+import { outputWithJq } from "../../lib/output.js";
+
+async function getIssue() {
+	const issueId = process.argv[2];
+
+	if (!issueId) {
+		console.error("Error: Please provide issue ID or identifier");
+		console.error(
+			"Usage: npx tsx scripts/issues/get.ts <issueId or identifier>"
+		);
+		process.exit(1);
+	}
+
+	// Check if it's an identifier (e.g., AA-123) or UUID
+	let issue;
+
+	if (issueId.includes("-") && issueId.split("-")[0].match(/^[A-Z]+$/)) {
+		// It's an identifier like AA-123
+		const issueResult = await client.issue(issueId);
+		issue = issueResult;
+	} else {
+		// It's a UUID
+		const issueResult = await client.issue(issueId);
+		issue = issueResult;
+	}
+
+	if (!issue) {
+		console.error("Issue not found");
+		process.exit(1);
+	}
+
+	const state = await issue.state;
+	const assignee = await issue.assignee;
+	const creator = await issue.creator;
+
+	outputWithJq({
+		id: issue.id,
+		identifier: issue.identifier,
+		title: issue.title,
+		description: issue.description,
+		status: state?.name || "Unknown",
+		priority: issue.priority,
+		priorityLabel: issue.priorityLabel,
+		assignee: assignee
+			? {
+					id: assignee.id,
+					name: assignee.name,
+					email: assignee.email,
+				}
+			: null,
+		creator: creator
+			? {
+					id: creator.id,
+					name: creator.name,
+					email: creator.email,
+				}
+			: null,
+		url: issue.url,
+		createdAt: issue.createdAt,
+		updatedAt: issue.updatedAt,
+	});
+}
+
+getIssue().catch((error) => {
+	console.error("Error fetching issue:", error.message);
+	process.exit(1);
+});

package/templates/base/.claude/skills/linear/scripts/issues/list.ts

@@ -0,0 +1,67 @@
+import { client } from "../../lib/client.js";
+import { outputWithJq } from "../../lib/output.js";
+import { getTeamIdOrExit } from "../../lib/config.js";
+
+interface ListOptions {
+	mine: boolean;
+	unassigned: boolean;
+	status: string | null;
+}
+
+function parseArgs(): ListOptions {
+	const args = process.argv.slice(2);
+	return {
+		mine: args.includes("--mine"),
+		unassigned: args.includes("--unassigned"),
+		status: args.find((a) => a.startsWith("--status="))?.split("=")[1] || null,
+	};
+}
+
+async function listIssues() {
+	const teamId = getTeamIdOrExit(2);
+	const options = parseArgs();
+
+	const viewer = await client.viewer;
+
+	// Build filter based on options
+	const filter: Record<string, unknown> = {
+		team: { id: { eq: teamId } },
+	};
+
+	// Only filter by assignee if --mine flag is passed
+	if (options.mine) {
+		filter.assignee = { id: { eq: viewer.id } };
+	} else if (options.unassigned) {
+		filter.assignee = { null: true };
+	}
+
+	// Filter by status name if provided
+	if (options.status) {
+		filter.state = { name: { eqIgnoreCase: options.status } };
+	}
+
+	const issuesResponse = await client.issues({
+		filter,
+		first: 50,
+	});
+
+	const issues = await Promise.all(
+		issuesResponse.nodes.map(async (issue) => ({
+			id: issue.id,
+			identifier: issue.identifier,
+			title: issue.title,
+			status: (await issue.state)?.name || "Unknown",
+			priority: issue.priority,
+			priorityLabel: issue.priorityLabel,
+			assignee: (await issue.assignee)?.name || null,
+			url: issue.url,
+		}))
+	);
+
+	outputWithJq({ issues });
+}
+
+listIssues().catch((error) => {
+	console.error("Error listing issues:", error.message);
+	process.exit(1);
+});

package/templates/base/.claude/skills/linear/scripts/issues/update.ts

@@ -0,0 +1,281 @@
+import { client } from "../../lib/client.js";
+import { outputWithJq } from "../../lib/output.js";
+
+/**
+ * Check if a string looks like an issue identifier (e.g., AA-123, ENG-456)
+ */
+function isIssueIdentifier(str: string): boolean {
+	return /^[A-Z]+-\d+$/i.test(str);
+}
+
+/**
+ * Resolve an issue identifier (AA-123) to its UUID.
+ * If already a UUID, returns as-is.
+ */
+async function resolveIssueId(idOrIdentifier: string): Promise<string> {
+	if (!isIssueIdentifier(idOrIdentifier)) {
+		// Assume it's already a UUID
+		return idOrIdentifier;
+	}
+
+	// Look up the issue by identifier
+	const issue = await client.issue(idOrIdentifier);
+	if (!issue) {
+		throw new Error(`Issue not found: ${idOrIdentifier}`);
+	}
+	return issue.id;
+}
+
+interface UpdateOptions {
+	title?: string;
+	description?: string;
+	stateId?: string;
+	priority?: number;
+	assigneeId?: string | null;
+	labelIds?: string[];
+	projectId?: string | null;
+	estimate?: number | null;
+	dueDate?: string | null;
+	parentId?: string | null;
+	cycleId?: string | null;
+}
+
+function printUsage() {
+	console.error("Usage: npx tsx scripts/issues/update.ts --issue <issueId> [options] --json");
+	console.error("       npx tsx scripts/issues/update.ts <issueId> [options] --json  (legacy)");
+	console.error("");
+	console.error("Options:");
+	console.error("  --issue <id>         Issue ID or identifier (e.g., ABC-123) (required)");
+	console.error("  --title <text>       New title");
+	console.error("  --description <text> New description (markdown supported)");
+	console.error("  --state <id>         Workflow state ID");
+	console.error("  --priority <0-4>     Priority: 0=None, 1=Urgent, 2=High, 3=Medium, 4=Low");
+	console.error("  --assignee <id>      User ID (use 'none' to unassign)");
+	console.error("  --labels <ids>       Comma-separated label IDs (replaces existing)");
+	console.error("  --project <id>       Project ID (use 'none' to remove)");
+	console.error("  --estimate <points>  Point estimate (use 'none' to clear)");
+	console.error("  --due <YYYY-MM-DD>   Due date (use 'none' to clear)");
+	console.error("  --parent <id>        Parent issue ID or identifier (e.g., AA-123) (use 'none' to remove)");
+	console.error("  --cycle <id>         Cycle/sprint ID (use 'none' to remove)");
+	console.error("  --json               Output as JSON (recommended for scripting)");
+	console.error("");
+	console.error("Examples:");
+	console.error("  npx tsx scripts/issues/update.ts --issue ABC-123 --priority 1 --json");
+	console.error("  npx tsx scripts/issues/update.ts --issue ABC-123 --state state-id --assignee user-id --json");
+	console.error("  npx tsx scripts/issues/update.ts ABC-123 --assignee none --json  (legacy positional)");
+}
+
+function getArgValue(args: string[], flag: string): string | undefined {
+	const index = args.indexOf(flag);
+	if (index !== -1 && args[index + 1] && !args[index + 1].startsWith("--")) {
+		return args[index + 1];
+	}
+	return undefined;
+}
+
+function parseArgs(): { issueId: string; updates: UpdateOptions } | null {
+	const args = process.argv.slice(2);
+
+	if (args.length === 0) {
+		console.error("Error: Please provide issue ID");
+		console.error("Use --issue ABC-123 or provide as first argument");
+		console.error("");
+		printUsage();
+		return null;
+	}
+
+	let issueId: string | undefined;
+	let optionsStartIndex = 0;
+
+	// Check for --issue flag (new named pattern - recommended)
+	issueId = getArgValue(args, "--issue");
+
+	// If no --issue flag, check for positional issueId (legacy backwards compatibility)
+	if (!issueId && args[0] && !args[0].startsWith("--")) {
+		issueId = args[0];
+		optionsStartIndex = 1;
+	}
+
+	if (!issueId) {
+		console.error("Error: Please provide issue ID");
+		console.error("Use --issue ABC-123 or provide as first argument");
+		console.error("");
+		printUsage();
+		return null;
+	}
+
+	const updates: UpdateOptions = {};
+
+	// Parse named options
+	for (let i = optionsStartIndex; i < args.length; i++) {
+		const arg = args[i];
+		const nextArg = args[i + 1];
+
+		// Skip already-processed --issue flag
+		if (arg === "--issue") {
+			if (nextArg && !nextArg.startsWith("--")) {
+				i++; // Skip the value too
+			}
+			continue;
+		}
+
+		switch (arg) {
+			case "--title":
+				if (nextArg && !nextArg.startsWith("--")) {
+					updates.title = nextArg;
+					i++;
+				}
+				break;
+			case "--description":
+				if (nextArg && !nextArg.startsWith("--")) {
+					updates.description = nextArg;
+					i++;
+				}
+				break;
+			case "--state":
+				if (nextArg && !nextArg.startsWith("--")) {
+					updates.stateId = nextArg;
+					i++;
+				}
+				break;
+			case "--priority":
+				if (nextArg && !nextArg.startsWith("--")) {
+					const priority = parseInt(nextArg);
+					if (priority >= 0 && priority <= 4) {
+						updates.priority = priority;
+					} else {
+						console.error("Error: Priority must be 0-4");
+						return null;
+					}
+					i++;
+				}
+				break;
+			case "--assignee":
+				if (nextArg && !nextArg.startsWith("--")) {
+					updates.assigneeId = nextArg === "none" || nextArg === "null" ? null : nextArg;
+					i++;
+				}
+				break;
+			case "--labels":
+				if (nextArg && !nextArg.startsWith("--")) {
+					updates.labelIds = nextArg.split(",").map(id => id.trim());
+					i++;
+				}
+				break;
+			case "--project":
+				if (nextArg && !nextArg.startsWith("--")) {
+					updates.projectId = nextArg === "none" || nextArg === "null" ? null : nextArg;
+					i++;
+				}
+				break;
+			case "--estimate":
+				if (nextArg && !nextArg.startsWith("--")) {
+					updates.estimate = nextArg === "none" || nextArg === "null" ? null : parseInt(nextArg);
+					i++;
+				}
+				break;
+			case "--due":
+				if (nextArg && !nextArg.startsWith("--")) {
+					updates.dueDate = nextArg === "none" || nextArg === "null" ? null : nextArg;
+					i++;
+				}
+				break;
+			case "--parent":
+				if (nextArg && !nextArg.startsWith("--")) {
+					updates.parentId = nextArg === "none" || nextArg === "null" ? null : nextArg;
+					i++;
+				}
+				break;
+			case "--cycle":
+				if (nextArg && !nextArg.startsWith("--")) {
+					updates.cycleId = nextArg === "none" || nextArg === "null" ? null : nextArg;
+					i++;
+				}
+				break;
+			case "--json":
+				// Handled by outputWithJq
+				break;
+			default:
+				// Ignore unknown flags
+				break;
+		}
+	}
+
+	if (Object.keys(updates).length === 0) {
+		console.error("Error: No updates provided");
+		console.error("");
+		printUsage();
+		return null;
+	}
+
+	return { issueId, updates };
+}
+
+async function updateIssue() {
+	const parsed = parseArgs();
+	if (!parsed) {
+		process.exit(1);
+	}
+
+	const { issueId, updates } = parsed;
+
+	// Resolve parentId if it's an identifier (AA-123) to UUID
+	// Skip resolution if null (removing parent)
+	let resolvedParentId: string | null | undefined = updates.parentId;
+	if (updates.parentId !== undefined && updates.parentId !== null) {
+		resolvedParentId = await resolveIssueId(updates.parentId);
+	}
+
+	// Build the input object with only defined fields
+	const input = {
+		...(updates.title !== undefined && { title: updates.title }),
+		...(updates.description !== undefined && { description: updates.description }),
+		...(updates.stateId !== undefined && { stateId: updates.stateId }),
+		...(updates.priority !== undefined && { priority: updates.priority }),
+		...(updates.assigneeId !== undefined && { assigneeId: updates.assigneeId }),
+		...(updates.labelIds !== undefined && { labelIds: updates.labelIds }),
+		...(updates.projectId !== undefined && { projectId: updates.projectId }),
+		...(updates.estimate !== undefined && { estimate: updates.estimate }),
+		...(updates.dueDate !== undefined && { dueDate: updates.dueDate }),
+		...(resolvedParentId !== undefined && { parentId: resolvedParentId }),
+		...(updates.cycleId !== undefined && { cycleId: updates.cycleId }),
+	};
+
+	const issuePayload = await client.updateIssue(issueId, input);
+	const issue = await issuePayload.issue;
+
+	if (!issue) {
+		console.error("Failed to update issue");
+		process.exit(1);
+	}
+
+	// Fetch additional details for output
+	const state = await issue.state;
+	const assignee = await issue.assignee;
+	const project = await issue.project;
+	const parent = await issue.parent;
+	const labels = await issue.labels();
+
+	outputWithJq({
+		id: issue.id,
+		identifier: issue.identifier,
+		title: issue.title,
+		description: issue.description,
+		url: issue.url,
+		priority: issue.priority,
+		priorityLabel: issue.priorityLabel,
+		estimate: issue.estimate,
+		dueDate: issue.dueDate,
+		state: state ? { id: state.id, name: state.name } : null,
+		assignee: assignee ? { id: assignee.id, name: assignee.name, email: assignee.email } : null,
+		project: project ? { id: project.id, name: project.name } : null,
+		parent: parent ? { id: parent.id, identifier: parent.identifier } : null,
+		labels: labels.nodes.map(l => ({ id: l.id, name: l.name })),
+		updatedAt: issue.updatedAt,
+	});
+}
+
+updateIssue().catch((error) => {
+	console.error("Error updating issue:", error.message);
+	process.exit(1);
+});

package/templates/base/.claude/skills/linear/scripts/labels/add-to-issue.ts

@@ -0,0 +1,63 @@
+import { client } from "../../lib/client.js";
+import { outputWithJq } from "../../lib/output.js";
+
+async function addLabelToIssue() {
+	const issueId = process.argv[2];
+	const labelId = process.argv[3];
+
+	if (!issueId || !labelId) {
+		console.error("Error: Please provide issue ID and label ID");
+		console.error(
+			"Usage: npx tsx scripts/labels/add-to-issue.ts <issueId> <labelId>"
+		);
+		console.error("Tip: Use scripts/labels/list.ts to see available labels");
+		process.exit(1);
+	}
+
+	// Get current labels
+	const issue = await client.issue(issueId);
+	if (!issue) {
+		console.error("Issue not found");
+		process.exit(1);
+	}
+
+	const currentLabels = await issue.labels();
+	const currentLabelIds = currentLabels.nodes.map((label) => label.id);
+
+	// Add new label if not already present
+	if (currentLabelIds.includes(labelId)) {
+		console.error("Label already attached to issue");
+		process.exit(1);
+	}
+
+	const updatedLabelIds = [...currentLabelIds, labelId];
+
+	const issuePayload = await client.updateIssue(issueId, {
+		labelIds: updatedLabelIds,
+	});
+
+	const updatedIssue = await issuePayload.issue;
+
+	if (!updatedIssue) {
+		console.error("Failed to add label to issue");
+		process.exit(1);
+	}
+
+	const labels = await updatedIssue.labels();
+
+	outputWithJq({
+		id: updatedIssue.id,
+		identifier: updatedIssue.identifier,
+		title: updatedIssue.title,
+		labels: labels.nodes.map((label) => ({
+			id: label.id,
+			name: label.name,
+			color: label.color,
+		})),
+	});
+}
+
+addLabelToIssue().catch((error) => {
+	console.error("Error adding label to issue:", error.message);
+	process.exit(1);
+});

package/templates/base/.claude/skills/linear/scripts/labels/create.ts

@@ -0,0 +1,45 @@
+import { client } from "../../lib/client.js";
+import { outputWithJq } from "../../lib/output.js";
+import { getTeamIdOrExit } from "../../lib/config.js";
+
+async function createLabel() {
+	const name = process.argv[2];
+
+	if (!name) {
+		console.error("Error: Please provide label name");
+		console.error("");
+		console.error("Usage: npx tsx scripts/labels/create.ts <name> [teamId] [color]");
+		console.error("");
+		console.error("If teamId is omitted, uses default from .claude/linear-config.json");
+		process.exit(1);
+	}
+
+	const teamId = getTeamIdOrExit(3);
+
+	const color = process.argv[4];
+
+	const labelPayload = await client.createIssueLabel({
+		name,
+		teamId,
+		...(color && { color }),
+	});
+
+	const label = await labelPayload.issueLabel;
+
+	if (!label) {
+		console.error("Failed to create label");
+		process.exit(1);
+	}
+
+	outputWithJq({
+		id: label.id,
+		name: label.name,
+		color: label.color,
+		description: label.description,
+	});
+}
+
+createLabel().catch((error) => {
+	console.error("Error creating label:", error.message);
+	process.exit(1);
+});

package/templates/base/.claude/skills/linear/scripts/labels/list.ts

@@ -0,0 +1,30 @@
+import { client } from "../../lib/client.js";
+import { outputWithJq } from "../../lib/output.js";
+import { getTeamIdOrExit } from "../../lib/config.js";
+
+async function listLabels() {
+	const teamId = getTeamIdOrExit(2);
+
+	const team = await client.team(teamId);
+
+	if (!team) {
+		console.error("Team not found");
+		process.exit(1);
+	}
+
+	const labelsResponse = await team.labels();
+
+	const labels = labelsResponse.nodes.map((label) => ({
+		id: label.id,
+		name: label.name,
+		color: label.color,
+		description: label.description,
+	}));
+
+	outputWithJq({ labels });
+}
+
+listLabels().catch((error) => {
+	console.error("Error listing labels:", error.message);
+	process.exit(1);
+});

package/templates/base/.claude/skills/linear/scripts/list-teams.ts

@@ -0,0 +1,52 @@
+import { client } from "../lib/client.js";
+import { outputWithJq } from "../lib/output.js";
+
+interface TeamOutput {
+	id: string;
+	name: string;
+	key: string;
+}
+
+interface ProjectOutput {
+	id: string;
+	name: string;
+	teamId: string | null;
+}
+
+interface Output {
+	teams: TeamOutput[];
+	projects: ProjectOutput[];
+}
+
+async function listTeamsAndProjects(): Promise<Output> {
+	// Fetch teams
+	const teamsResponse = await client.teams();
+	const teams: TeamOutput[] = teamsResponse.nodes.map((team) => ({
+		id: team.id,
+		name: team.name,
+		key: team.key,
+	}));
+
+	// Fetch projects
+	const projectsResponse = await client.projects();
+	const projects: ProjectOutput[] = await Promise.all(
+		projectsResponse.nodes.map(async (project) => {
+			const teams = await project.teams();
+			return {
+				id: project.id,
+				name: project.name,
+				teamId: teams.nodes[0]?.id || null,
+			};
+		})
+	);
+
+	return { teams, projects };
+}
+
+// Main execution
+listTeamsAndProjects()
+	.then(outputWithJq)
+	.catch((error) => {
+		console.error("Error fetching teams and projects:", error.message);
+		process.exit(1);
+	});

package/templates/base/.claude/skills/linear/scripts/setup/setup-credentials.ts

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+
+import { writeFileSync, mkdirSync, existsSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import * as readline from "readline";
+
+async function promptForApiKey(): Promise<string> {
+	const rl = readline.createInterface({
+		input: process.stdin,
+		output: process.stdout,
+	});
+
+	return new Promise((resolve) => {
+		rl.question(
+			"Enter your Linear API key (get it from https://linear.app/settings/api): ",
+			(answer) => {
+				rl.close();
+				resolve(answer.trim());
+			}
+		);
+	});
+}
+
+async function main() {
+	console.log("🔧 Linear Credentials Setup\n");
+
+	// Check if credentials already exist
+	const credentialsDir = join(homedir(), ".linear");
+	const credentialsPath = join(credentialsDir, "credentials");
+
+	if (existsSync(credentialsPath)) {
+		console.log("⚠️  Credentials file already exists at:");
+		console.log(`   ${credentialsPath}\n`);
+
+		const rl = readline.createInterface({
+			input: process.stdin,
+			output: process.stdout,
+		});
+
+		const overwrite = await new Promise<string>((resolve) => {
+			rl.question("Do you want to overwrite it? (yes/no): ", (answer) => {
+				rl.close();
+				resolve(answer.trim().toLowerCase());
+			});
+		});
+
+		if (overwrite !== "yes" && overwrite !== "y") {
+			console.log("\n✅ Setup cancelled. Existing credentials preserved.");
+			return;
+		}
+	}
+
+	// Get API key from user
+	const apiKey = await promptForApiKey();
+
+	if (!apiKey) {
+		console.error("\n❌ Error: API key cannot be empty");
+		process.exit(1);
+	}
+
+	// Validate API key format (Linear keys start with lin_api_)
+	if (!apiKey.startsWith("lin_api_")) {
+		console.warn(
+			"\n⚠️  Warning: Linear API keys typically start with 'lin_api_'"
+		);
+		console.warn("   Make sure you copied the correct key.\n");
+	}
+
+	// Create .linear directory if it doesn't exist
+	if (!existsSync(credentialsDir)) {
+		mkdirSync(credentialsDir, { recursive: true, mode: 0o700 });
+	}
+
+	// Write credentials file
+	try {
+		writeFileSync(credentialsPath, apiKey, { mode: 0o600 });
+		console.log("\n✅ Credentials saved successfully!");
+		console.log(`   Location: ${credentialsPath}`);
+		console.log(`   Permissions: 600 (read/write for owner only)\n`);
+		console.log("🎉 You can now use the Linear scripts!\n");
+		console.log("Try:");
+		console.log("  npx tsx list-teams.ts");
+		console.log("  npx tsx scripts/issues/list.ts <teamId>");
+	} catch (error) {
+		console.error(
+			`\n❌ Error writing credentials: ${error instanceof Error ? error.message : String(error)}`
+		);
+		process.exit(1);
+	}
+}
+
+main().catch((error) => {
+	console.error(`\n❌ Setup failed: ${error.message}`);
+	process.exit(1);
+});