linmux 0.1.0

package/dist/lib/issue-search-runtime.js

@@ -0,0 +1,114 @@
+import { getLastComplexity, withFetchInterception } from "../core/transport/fetch-interceptor.js";
+import { withRateLimitRetry } from "../core/transport/rate-limit.js";
+import "../core/transport/index.js";
+import { createLinearClient } from "../core/client/factory.js";
+import "../core/client/index.js";
+import { loadConfig } from "../core/config/store.js";
+import "../core/config/index.js";
+import { parseFields, project } from "../core/projection/project.js";
+import { resolveWorkspace } from "../core/workspace/resolver.js";
+import { parsePagination } from "../core/pagination/flags.js";
+import "../core/pagination/index.js";
+import { buildIssueFilter } from "./filter-heuristics.js";
+//#region src/lib/issue-search-runtime.ts
+async function issueSearchRuntime(input) {
+	const config = (input.loadConfigOverride ?? loadConfig)();
+	const envForResolver = {};
+	if (input.env.LINEAR_WORKSPACE !== void 0) envForResolver.LINEAR_WORKSPACE = input.env.LINEAR_WORKSPACE;
+	if (input.env.LINEAR_API_KEY !== void 0) envForResolver.LINEAR_API_KEY = input.env.LINEAR_API_KEY;
+	const resolved = resolveWorkspace({
+		flags: input.flags.workspace ? { workspace: input.flags.workspace } : {},
+		env: envForResolver,
+		config
+	});
+	const fields = parseFields(input.flags.fields ?? "defaults", "issue");
+	const { first, after } = parsePagination({
+		...input.flags.limit !== void 0 ? { limit: input.flags.limit } : {},
+		...input.flags.cursor !== void 0 ? { cursor: input.flags.cursor } : {}
+	});
+	const filter = buildIssueFilter(input.flags);
+	const client = (input.clientFactoryOverride ?? createLinearClient)(resolved);
+	return withFetchInterception(async () => {
+		const vars = { first };
+		if (after !== void 0) vars.after = after;
+		if (filter !== void 0) vars.filter = filter;
+		if (input.flags.includeArchived === true) vars.includeArchived = true;
+		const payload = await withRateLimitRetry(() => client.searchIssues(input.args.query, vars), input.retryOptsOverride);
+		const noSnippet = input.flags.noSnippet === true;
+		const projected = await Promise.all(payload.nodes.map(async (result) => {
+			const issue = {};
+			for (const k of Object.keys(result)) {
+				if (k === "metadata") continue;
+				if (RELATION_KEYS.has(k)) {
+					const desc = Object.getOwnPropertyDescriptor(result, k);
+					if (desc) Object.defineProperty(issue, k, desc);
+					continue;
+				}
+				issue[k] = result[k];
+			}
+			if (!noSnippet) {
+				const md = result.metadata;
+				if (md && typeof md === "object") {
+					const snippetVal = md.snippet;
+					if (typeof snippetVal === "string") issue.snippet = snippetVal;
+				}
+			}
+			return project(await hydrateForProjection(issue, fields), fields);
+		}));
+		const complexity = getLastComplexity();
+		return {
+			data: projected,
+			meta: {
+				workspace: resolved.name,
+				workspaceSource: resolved.source,
+				pageInfo: {
+					hasNextPage: Boolean(payload.pageInfo?.hasNextPage),
+					endCursor: payload.pageInfo?.endCursor ?? null,
+					hasPreviousPage: Boolean(payload.pageInfo?.hasPreviousPage),
+					startCursor: payload.pageInfo?.startCursor ?? null
+				},
+				totalCount: payload.totalCount,
+				...complexity !== void 0 ? { complexity } : {}
+			}
+		};
+	});
+}
+const RELATION_KEYS = new Set([
+	"state",
+	"assignee",
+	"team",
+	"project",
+	"cycle",
+	"parent"
+]);
+async function hydrateForProjection(issue, spec) {
+	const needs = neededRelations(spec);
+	if (needs.size === 0) {
+		const out = {};
+		for (const k of Object.keys(issue)) if (!RELATION_KEYS.has(k)) out[k] = issue[k];
+		return out;
+	}
+	const hydrated = {};
+	for (const k of Object.keys(issue)) if (RELATION_KEYS.has(k)) {
+		if (needs.has(k)) {
+			const value = issue[k];
+			hydrated[k] = await resolveLazy(value);
+		}
+	} else hydrated[k] = issue[k];
+	return hydrated;
+}
+function neededRelations(spec) {
+	if (spec === "*") return new Set(RELATION_KEYS);
+	const out = /* @__PURE__ */ new Set();
+	for (const path of spec) {
+		const head = path.split(".")[0];
+		if (head && RELATION_KEYS.has(head)) out.add(head);
+	}
+	return out;
+}
+async function resolveLazy(value) {
+	if (value && typeof value.then === "function") return await value;
+	return value;
+}
+//#endregion
+export { issueSearchRuntime };

package/dist/lib/issue-transition-runtime.js

@@ -0,0 +1,131 @@
+import { LinearAgentError } from "../core/errors/error.js";
+import { getLastComplexity, withFetchInterception } from "../core/transport/fetch-interceptor.js";
+import { withRateLimitRetry } from "../core/transport/rate-limit.js";
+import "../core/transport/index.js";
+import { createLinearClient } from "../core/client/factory.js";
+import "../core/client/index.js";
+import { loadConfig } from "../core/config/store.js";
+import "../core/config/index.js";
+import { parseFields, project } from "../core/projection/project.js";
+import { resolveWorkspace } from "../core/workspace/resolver.js";
+import { requireExplicitWorkspaceForWrite } from "../core/workspace/write-guard.js";
+import { ISSUE_IDENTIFIER_RE } from "./filter-heuristics.js";
+import { resolveStateNameToId } from "../core/resolvers/state.js";
+import "../core/resolvers/index.js";
+//#region src/lib/issue-transition-runtime.ts
+async function issueTransitionRuntime(input) {
+	const config = (input.loadConfigOverride ?? loadConfig)();
+	const envForResolver = {};
+	if (input.env.LINEAR_WORKSPACE !== void 0) envForResolver.LINEAR_WORKSPACE = input.env.LINEAR_WORKSPACE;
+	if (input.env.LINEAR_API_KEY !== void 0) envForResolver.LINEAR_API_KEY = input.env.LINEAR_API_KEY;
+	const resolved = resolveWorkspace({
+		flags: input.flags.workspace ? { workspace: input.flags.workspace } : {},
+		env: envForResolver,
+		config
+	});
+	requireExplicitWorkspaceForWrite(resolved, input.flags.allowActiveWorkspaceWrite ?? false);
+	const fields = parseFields(input.flags.fields ?? "defaults", "issue");
+	const client = (input.clientFactoryOverride ?? createLinearClient)(resolved);
+	return withFetchInterception(async () => {
+		const ref = input.args.identifier;
+		const issue = await resolveIssue(client, ref, input.retryOptsOverride);
+		if (!issue) throw new LinearAgentError({
+			code: "ISSUE_NOT_FOUND",
+			message: `issue not found: ${ref}`,
+			details: { ref }
+		});
+		const issueIdRaw = issue.id;
+		if (typeof issueIdRaw !== "string") throw new LinearAgentError({
+			code: "ISSUE_NOT_FOUND",
+			message: `issue not found: ${ref}`,
+			details: { ref }
+		});
+		const issueId = issueIdRaw;
+		const teamRaw = await Promise.resolve(issue.team);
+		const teamId = teamRaw && typeof teamRaw === "object" && typeof teamRaw.id === "string" ? teamRaw.id : void 0;
+		if (!teamId) throw new LinearAgentError({
+			code: "ISSUE_NOT_FOUND",
+			message: `issue has no team: ${ref}`,
+			details: { ref }
+		});
+		const stateId = await resolveStateNameToId(client, resolved.name ?? "_api-key-env_", teamId, input.args.state, input.retryOptsOverride);
+		const payload = await withRateLimitRetry(() => client.updateIssue(issueId, { stateId }), input.retryOptsOverride);
+		if (!payload.success) throw LinearAgentError.linear.apiError({
+			message: "updateIssue returned success=false",
+			details: { lastSyncId: payload.lastSyncId }
+		});
+		let updated;
+		if (payload.issue !== void 0) {
+			const u = await Promise.resolve(payload.issue);
+			if (u !== void 0 && u !== null) updated = u;
+		}
+		let data;
+		if (updated) data = project(await hydrateForProjection(updated, fields), fields);
+		else data = { id: issueId };
+		const complexity = getLastComplexity();
+		const meta = {
+			workspace: resolved.name,
+			workspaceSource: resolved.source,
+			...complexity !== void 0 ? { complexity } : {}
+		};
+		return {
+			data,
+			meta
+		};
+	});
+}
+async function resolveIssue(client, ref, retryOpts) {
+	const m = ISSUE_IDENTIFIER_RE.exec(ref);
+	if (m) {
+		const teamKey = m[1].toUpperCase();
+		const number = Number(m[2]);
+		const filter = {
+			team: { key: { eq: teamKey } },
+			number: { eq: number }
+		};
+		return (await withRateLimitRetry(() => client.issues({
+			filter,
+			first: 1
+		}), retryOpts)).nodes[0];
+	}
+	return await withRateLimitRetry(() => client.issue(ref), retryOpts) ?? void 0;
+}
+const RELATION_KEYS = new Set([
+	"state",
+	"assignee",
+	"team",
+	"project",
+	"cycle",
+	"parent"
+]);
+async function hydrateForProjection(issue, spec) {
+	const needs = neededRelations(spec);
+	if (needs.size === 0) {
+		const out = {};
+		for (const k of Object.keys(issue)) if (!RELATION_KEYS.has(k)) out[k] = issue[k];
+		return out;
+	}
+	const hydrated = {};
+	for (const k of Object.keys(issue)) if (RELATION_KEYS.has(k)) {
+		if (needs.has(k)) {
+			const value = issue[k];
+			hydrated[k] = await resolveLazy(value);
+		}
+	} else hydrated[k] = issue[k];
+	return hydrated;
+}
+function neededRelations(spec) {
+	if (spec === "*") return new Set(RELATION_KEYS);
+	const out = /* @__PURE__ */ new Set();
+	for (const path of spec) {
+		const head = path.split(".")[0];
+		if (head && RELATION_KEYS.has(head)) out.add(head);
+	}
+	return out;
+}
+async function resolveLazy(value) {
+	if (value && typeof value.then === "function") return await value;
+	return value;
+}
+//#endregion
+export { issueTransitionRuntime };

package/dist/lib/issue-trash-runtime.js

@@ -0,0 +1,84 @@
+import { LinearAgentError } from "../core/errors/error.js";
+import { getLastComplexity, withFetchInterception } from "../core/transport/fetch-interceptor.js";
+import { withRateLimitRetry } from "../core/transport/rate-limit.js";
+import "../core/transport/index.js";
+import { createLinearClient } from "../core/client/factory.js";
+import "../core/client/index.js";
+import { loadConfig } from "../core/config/store.js";
+import "../core/config/index.js";
+import { resolveWorkspace } from "../core/workspace/resolver.js";
+import { requireExplicitWorkspaceForWrite } from "../core/workspace/write-guard.js";
+import { ISSUE_IDENTIFIER_RE, UUID_RE } from "./filter-heuristics.js";
+//#region src/lib/issue-trash-runtime.ts
+async function issueTrashRuntime(input) {
+	const config = (input.loadConfigOverride ?? loadConfig)();
+	const envForResolver = {};
+	if (input.env.LINEAR_WORKSPACE !== void 0) envForResolver.LINEAR_WORKSPACE = input.env.LINEAR_WORKSPACE;
+	if (input.env.LINEAR_API_KEY !== void 0) envForResolver.LINEAR_API_KEY = input.env.LINEAR_API_KEY;
+	const resolved = resolveWorkspace({
+		flags: input.flags.workspace ? { workspace: input.flags.workspace } : {},
+		env: envForResolver,
+		config
+	});
+	requireExplicitWorkspaceForWrite(resolved, input.flags.allowActiveWorkspaceWrite ?? false);
+	const client = (input.clientFactoryOverride ?? createLinearClient)(resolved);
+	return withFetchInterception(async () => {
+		const ref = input.args.identifier;
+		const { id, identifier } = await resolveIssueRef(client, ref, input.retryOptsOverride);
+		const payload = await withRateLimitRetry(() => client.deleteIssue(id), input.retryOptsOverride);
+		if (!payload.success) throw LinearAgentError.linear.apiError({
+			message: "deleteIssue returned success=false",
+			details: { lastSyncId: payload.lastSyncId }
+		});
+		const data = {
+			id,
+			trashed: true
+		};
+		if (identifier !== void 0) data.identifier = identifier;
+		const complexity = getLastComplexity();
+		return {
+			data,
+			meta: {
+				workspace: resolved.name,
+				workspaceSource: resolved.source,
+				...complexity !== void 0 ? { complexity } : {}
+			}
+		};
+	});
+}
+async function resolveIssueRef(client, ref, retryOpts) {
+	if (UUID_RE.test(ref)) return { id: ref };
+	const m = ref.match(ISSUE_IDENTIFIER_RE);
+	if (!m) throw new LinearAgentError({
+		code: "ISSUE_NOT_FOUND",
+		message: `invalid issue ref: ${ref}`,
+		details: { ref }
+	});
+	const teamKey = m[1].toUpperCase();
+	const number = Number(m[2]);
+	const issue = (await withRateLimitRetry(() => client.issues({
+		filter: {
+			team: { key: { eq: teamKey } },
+			number: { eq: number }
+		},
+		first: 1,
+		includeArchived: true
+	}), retryOpts)).nodes[0];
+	if (!issue) throw new LinearAgentError({
+		code: "ISSUE_NOT_FOUND",
+		message: `issue not found: ${ref}`,
+		details: { ref }
+	});
+	const idRaw = issue.id;
+	if (typeof idRaw !== "string") throw new LinearAgentError({
+		code: "ISSUE_NOT_FOUND",
+		message: `issue not found: ${ref}`,
+		details: { ref }
+	});
+	const idRes = { id: idRaw };
+	const idn = issue.identifier;
+	if (typeof idn === "string") idRes.identifier = idn;
+	return idRes;
+}
+//#endregion
+export { issueTrashRuntime };

package/dist/lib/issue-update-runtime.js

@@ -0,0 +1,164 @@
+import { LinearAgentError } from "../core/errors/error.js";
+import { getLastComplexity, withFetchInterception } from "../core/transport/fetch-interceptor.js";
+import { withRateLimitRetry } from "../core/transport/rate-limit.js";
+import "../core/transport/index.js";
+import { createLinearClient } from "../core/client/factory.js";
+import "../core/client/index.js";
+import { loadConfig } from "../core/config/store.js";
+import "../core/config/index.js";
+import { parseFields, project } from "../core/projection/project.js";
+import { resolveWorkspace } from "../core/workspace/resolver.js";
+import { requireExplicitWorkspaceForWrite } from "../core/workspace/write-guard.js";
+import { ISSUE_IDENTIFIER_RE } from "./filter-heuristics.js";
+import { resolveCycleId } from "../core/resolvers/cycle.js";
+import { resolveLabelId, resolveLabelIds } from "../core/resolvers/label.js";
+import { resolveProjectId } from "../core/resolvers/project.js";
+import { resolveStateNameToId } from "../core/resolvers/state.js";
+import "../core/resolvers/index.js";
+import { resolveAssignee } from "./issue-create-runtime.js";
+//#region src/lib/issue-update-runtime.ts
+/**
+* Returns true if any field flag is set (i.e. the update is non-empty).
+* Empty-string `description` counts as set (intentional clear-the-description
+* value per Test 8).
+*/
+function hasAnyFieldFlag(flags) {
+	return flags.title !== void 0 || flags.description !== void 0 || flags.state !== void 0 || flags.assignee !== void 0 || flags.labels !== void 0 && flags.labels !== "" || flags.addLabel !== void 0 && flags.addLabel.length > 0 || flags.removeLabel !== void 0 && flags.removeLabel.length > 0 || flags.project !== void 0 || flags.cycle !== void 0 || flags.priority !== void 0;
+}
+const NO_FIELDS_MESSAGE = "no fields to update -- pass at least one of --title, --description, --state, --assignee, --labels, --add-label, --remove-label, --priority, --project, --cycle";
+async function issueUpdateRuntime(input) {
+	const config = (input.loadConfigOverride ?? loadConfig)();
+	const envForResolver = {};
+	if (input.env.LINEAR_WORKSPACE !== void 0) envForResolver.LINEAR_WORKSPACE = input.env.LINEAR_WORKSPACE;
+	if (input.env.LINEAR_API_KEY !== void 0) envForResolver.LINEAR_API_KEY = input.env.LINEAR_API_KEY;
+	const resolved = resolveWorkspace({
+		flags: input.flags.workspace ? { workspace: input.flags.workspace } : {},
+		env: envForResolver,
+		config
+	});
+	requireExplicitWorkspaceForWrite(resolved, input.flags.allowActiveWorkspaceWrite ?? false);
+	if (!hasAnyFieldFlag(input.flags)) throw new LinearAgentError({
+		code: "VALIDATION_NO_FIELDS",
+		message: NO_FIELDS_MESSAGE
+	});
+	const fields = parseFields(input.flags.fields ?? "defaults", "issue");
+	const client = (input.clientFactoryOverride ?? createLinearClient)(resolved);
+	return withFetchInterception(async () => {
+		const ref = input.args.identifier;
+		const issue = await resolveIssue(client, ref, input.retryOptsOverride);
+		if (!issue) throw new LinearAgentError({
+			code: "ISSUE_NOT_FOUND",
+			message: `issue not found: ${ref}`,
+			details: { ref }
+		});
+		const issueIdRaw = issue.id;
+		if (typeof issueIdRaw !== "string") throw new LinearAgentError({
+			code: "ISSUE_NOT_FOUND",
+			message: `issue not found: ${ref}`,
+			details: { ref }
+		});
+		const issueId = issueIdRaw;
+		const teamRaw = await Promise.resolve(issue.team);
+		const teamId = teamRaw && typeof teamRaw === "object" && typeof teamRaw.id === "string" ? teamRaw.id : void 0;
+		if (!teamId) throw new LinearAgentError({
+			code: "ISSUE_NOT_FOUND",
+			message: `issue has no team: ${ref}`,
+			details: { ref }
+		});
+		const workspaceKey = resolved.name ?? "_api-key-env_";
+		const flags = input.flags;
+		const updateInput = {};
+		if (flags.title !== void 0) updateInput.title = flags.title;
+		if (flags.description !== void 0) updateInput.description = flags.description;
+		if (flags.priority !== void 0) updateInput.priority = flags.priority;
+		if (flags.state !== void 0) updateInput.stateId = await resolveStateNameToId(client, workspaceKey, teamId, flags.state, input.retryOptsOverride);
+		if (flags.assignee !== void 0) updateInput.assigneeId = await resolveAssignee(client, flags.assignee, input.retryOptsOverride);
+		if (flags.project !== void 0) updateInput.projectId = await resolveProjectId(client, workspaceKey, flags.project, input.retryOptsOverride);
+		if (flags.cycle !== void 0) updateInput.cycleId = await resolveCycleId(client, workspaceKey, teamId, flags.cycle, input.retryOptsOverride);
+		if (flags.labels !== void 0 && flags.labels !== "") updateInput.labelIds = await resolveLabelIds(client, workspaceKey, teamId, flags.labels.split(",").map((s) => s.trim()).filter(Boolean), input.retryOptsOverride);
+		if (flags.addLabel !== void 0 && flags.addLabel.length > 0) updateInput.addedLabelIds = await Promise.all(flags.addLabel.map((l) => resolveLabelId(client, workspaceKey, teamId, l, input.retryOptsOverride)));
+		if (flags.removeLabel !== void 0 && flags.removeLabel.length > 0) updateInput.removedLabelIds = await Promise.all(flags.removeLabel.map((l) => resolveLabelId(client, workspaceKey, teamId, l, input.retryOptsOverride)));
+		if (Object.keys(updateInput).length === 0) throw new LinearAgentError({
+			code: "VALIDATION_NO_FIELDS",
+			message: NO_FIELDS_MESSAGE
+		});
+		const payload = await withRateLimitRetry(() => client.updateIssue(issueId, updateInput), input.retryOptsOverride);
+		if (!payload.success) throw LinearAgentError.linear.apiError({
+			message: "updateIssue returned success=false",
+			details: { lastSyncId: payload.lastSyncId }
+		});
+		let updated;
+		if (payload.issue !== void 0) {
+			const u = await Promise.resolve(payload.issue);
+			if (u !== void 0 && u !== null) updated = u;
+		}
+		let data;
+		if (updated) data = project(await hydrateForProjection(updated, fields), fields);
+		else data = { id: issueId };
+		const complexity = getLastComplexity();
+		const meta = {
+			workspace: resolved.name,
+			workspaceSource: resolved.source,
+			...complexity !== void 0 ? { complexity } : {}
+		};
+		return {
+			data,
+			meta
+		};
+	});
+}
+async function resolveIssue(client, ref, retryOpts) {
+	const m = ISSUE_IDENTIFIER_RE.exec(ref);
+	if (m) {
+		const teamKey = m[1].toUpperCase();
+		const number = Number(m[2]);
+		const filter = {
+			team: { key: { eq: teamKey } },
+			number: { eq: number }
+		};
+		return (await withRateLimitRetry(() => client.issues({
+			filter,
+			first: 1
+		}), retryOpts)).nodes[0];
+	}
+	return await withRateLimitRetry(() => client.issue(ref), retryOpts) ?? void 0;
+}
+const RELATION_KEYS = new Set([
+	"state",
+	"assignee",
+	"team",
+	"project",
+	"cycle",
+	"parent"
+]);
+async function hydrateForProjection(issue, spec) {
+	const needs = neededRelations(spec);
+	if (needs.size === 0) {
+		const out = {};
+		for (const k of Object.keys(issue)) if (!RELATION_KEYS.has(k)) out[k] = issue[k];
+		return out;
+	}
+	const hydrated = {};
+	for (const k of Object.keys(issue)) if (RELATION_KEYS.has(k)) {
+		if (needs.has(k)) {
+			const value = issue[k];
+			hydrated[k] = await resolveLazy(value);
+		}
+	} else hydrated[k] = issue[k];
+	return hydrated;
+}
+function neededRelations(spec) {
+	if (spec === "*") return new Set(RELATION_KEYS);
+	const out = /* @__PURE__ */ new Set();
+	for (const path of spec) {
+		const head = path.split(".")[0];
+		if (head && RELATION_KEYS.has(head)) out.add(head);
+	}
+	return out;
+}
+async function resolveLazy(value) {
+	if (value && typeof value.then === "function") return await value;
+	return value;
+}
+//#endregion
+export { issueUpdateRuntime };

package/dist/lib/label-create-runtime.js

@@ -0,0 +1,113 @@
+import { LinearAgentError } from "../core/errors/error.js";
+import { getLastComplexity, withFetchInterception } from "../core/transport/fetch-interceptor.js";
+import { withRateLimitRetry } from "../core/transport/rate-limit.js";
+import "../core/transport/index.js";
+import { createLinearClient } from "../core/client/factory.js";
+import "../core/client/index.js";
+import { loadConfig } from "../core/config/store.js";
+import "../core/config/index.js";
+import { parseFields, project } from "../core/projection/project.js";
+import { resolveWorkspace } from "../core/workspace/resolver.js";
+import { requireExplicitWorkspaceForWrite } from "../core/workspace/write-guard.js";
+import { TEAM_KEY_RE, UUID_RE } from "./filter-heuristics.js";
+//#region src/lib/label-create-runtime.ts
+async function labelCreateRuntime(input) {
+	const config = (input.loadConfigOverride ?? loadConfig)();
+	const envForResolver = {};
+	if (input.env.LINEAR_WORKSPACE !== void 0) envForResolver.LINEAR_WORKSPACE = input.env.LINEAR_WORKSPACE;
+	if (input.env.LINEAR_API_KEY !== void 0) envForResolver.LINEAR_API_KEY = input.env.LINEAR_API_KEY;
+	const resolved = resolveWorkspace({
+		flags: input.flags.workspace ? { workspace: input.flags.workspace } : {},
+		env: envForResolver,
+		config
+	});
+	requireExplicitWorkspaceForWrite(resolved, input.flags.allowActiveWorkspaceWrite ?? false);
+	if (input.flags.name === void 0 || input.flags.name === "") throw LinearAgentError.usage("--name is required");
+	if (input.flags.team === void 0 || input.flags.team === "") throw LinearAgentError.usage("--team is required");
+	const name = input.flags.name;
+	const teamRef = input.flags.team;
+	const fields = parseFields(input.flags.fields ?? "defaults", "label");
+	const client = (input.clientFactoryOverride ?? createLinearClient)(resolved);
+	return withFetchInterception(async () => {
+		let teamId;
+		if (UUID_RE.test(teamRef)) teamId = teamRef;
+		else {
+			const filter = TEAM_KEY_RE.test(teamRef) ? { key: { eq: teamRef.toUpperCase() } } : { name: { eq: teamRef } };
+			const team = (await withRateLimitRetry(() => client.teams({
+				filter,
+				first: 1
+			}), input.retryOptsOverride)).nodes[0];
+			if (!team) throw new LinearAgentError({
+				code: "TEAM_NOT_FOUND",
+				message: `team not found: ${teamRef}`,
+				details: { ref: teamRef }
+			});
+			teamId = team.id;
+		}
+		const createInput = {
+			name,
+			teamId
+		};
+		if (input.flags.color !== void 0) createInput.color = input.flags.color;
+		if (input.flags.description !== void 0) createInput.description = input.flags.description;
+		const payload = await withRateLimitRetry(() => client.createIssueLabel(createInput), input.retryOptsOverride);
+		if (!payload.success) throw LinearAgentError.linear.apiError({
+			message: "createIssueLabel returned success=false",
+			details: { lastSyncId: payload.lastSyncId }
+		});
+		let created;
+		if (payload.issueLabel !== void 0) {
+			const c = await Promise.resolve(payload.issueLabel);
+			if (c !== void 0 && c !== null) created = c;
+		}
+		let data;
+		if (created) data = project(await hydrateForProjection(created, fields), fields);
+		else data = {};
+		const complexity = getLastComplexity();
+		const meta = {
+			workspace: resolved.name,
+			workspaceSource: resolved.source,
+			...complexity !== void 0 ? { complexity } : {}
+		};
+		return {
+			data,
+			meta
+		};
+	});
+}
+const RELATION_KEYS = new Set([
+	"team",
+	"parent",
+	"creator"
+]);
+async function hydrateForProjection(label, spec) {
+	const needs = neededRelations(spec);
+	if (needs.size === 0) {
+		const out = {};
+		for (const k of Object.keys(label)) if (!RELATION_KEYS.has(k)) out[k] = label[k];
+		return out;
+	}
+	const hydrated = {};
+	for (const k of Object.keys(label)) if (RELATION_KEYS.has(k)) {
+		if (needs.has(k)) {
+			const value = label[k];
+			hydrated[k] = await resolveLazy(value);
+		}
+	} else hydrated[k] = label[k];
+	return hydrated;
+}
+function neededRelations(spec) {
+	if (spec === "*") return new Set(RELATION_KEYS);
+	const out = /* @__PURE__ */ new Set();
+	for (const path of spec) {
+		const head = path.split(".")[0];
+		if (head && RELATION_KEYS.has(head)) out.add(head);
+	}
+	return out;
+}
+async function resolveLazy(value) {
+	if (value && typeof value.then === "function") return await value;
+	return value;
+}
+//#endregion
+export { labelCreateRuntime };