linmux 0.1.0

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

@@ -0,0 +1,96 @@
+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";
+//#region src/lib/comment-create-runtime.ts
+async function commentCreateRuntime(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.body === void 0) throw LinearAgentError.usage("--body is required");
+	if (input.flags.issue === void 0 || input.flags.issue === "") throw LinearAgentError.usage("--issue is required");
+	const body = input.flags.body;
+	const issue = input.flags.issue;
+	const fields = parseFields(input.flags.fields ?? "defaults", "comment");
+	const client = (input.clientFactoryOverride ?? createLinearClient)(resolved);
+	return withFetchInterception(async () => {
+		const createInput = {
+			body,
+			issueId: issue
+		};
+		if (input.flags.parent !== void 0) createInput.parentId = input.flags.parent;
+		const payload = await withRateLimitRetry(() => client.createComment(createInput), input.retryOptsOverride);
+		if (!payload.success) throw LinearAgentError.linear.apiError({
+			message: "createComment returned success=false",
+			details: { lastSyncId: payload.lastSyncId }
+		});
+		let created;
+		if (payload.comment !== void 0) {
+			const c = await Promise.resolve(payload.comment);
+			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([
+	"user",
+	"issue",
+	"parent"
+]);
+async function hydrateForProjection(comment, spec) {
+	const needs = neededRelations(spec);
+	if (needs.size === 0) {
+		const out = {};
+		for (const k of Object.keys(comment)) if (!RELATION_KEYS.has(k)) out[k] = comment[k];
+		return out;
+	}
+	const hydrated = {};
+	for (const k of Object.keys(comment)) if (RELATION_KEYS.has(k)) {
+		if (needs.has(k)) {
+			const value = comment[k];
+			hydrated[k] = await resolveLazy(value);
+		}
+	} else hydrated[k] = comment[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 { commentCreateRuntime };

package/dist/lib/comment-delete-runtime.js

@@ -0,0 +1,46 @@
+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";
+//#region src/lib/comment-delete-runtime.ts
+async function commentDeleteRuntime(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 payload = await withRateLimitRetry(() => client.deleteComment(input.args.id), input.retryOptsOverride);
+		if (!payload.success) throw LinearAgentError.linear.apiError({
+			message: "deleteComment returned success=false",
+			details: { lastSyncId: payload.lastSyncId }
+		});
+		const complexity = getLastComplexity();
+		const meta = {
+			workspace: resolved.name,
+			workspaceSource: resolved.source,
+			...complexity !== void 0 ? { complexity } : {}
+		};
+		return {
+			data: {
+				id: input.args.id,
+				deleted: true
+			},
+			meta
+		};
+	});
+}
+//#endregion
+export { commentDeleteRuntime };

package/dist/lib/comment-list-runtime.js

@@ -0,0 +1,182 @@
+import { LinearAgentError } from "../core/errors/error.js";
+import { redact } from "../core/redact/redact.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 { parsePagination } from "../core/pagination/flags.js";
+import "../core/pagination/index.js";
+import { ISSUE_IDENTIFIER_RE, UUID_RE } from "./filter-heuristics.js";
+import { validateAndMergeIncludes } from "./include-fragments.js";
+//#region src/lib/comment-list-runtime.ts
+async function commentListRuntime(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", "comment");
+	const { first, after } = parsePagination({
+		...input.flags.limit !== void 0 ? { limit: input.flags.limit } : {},
+		...input.flags.cursor !== void 0 ? { cursor: input.flags.cursor } : {}
+	});
+	const client = (input.clientFactoryOverride ?? createLinearClient)(resolved);
+	const includes = input.flags.include ?? [];
+	if (includes.length > 0) {
+		const query = composeCommentListWithIncludes(validateAndMergeIncludes("comment list", includes));
+		return withFetchInterception(async () => {
+			let issueIdFilter;
+			if (input.flags.issue !== void 0 && input.flags.issue !== "") issueIdFilter = { issue: { id: { eq: await resolveIssueRefToUuid(client, input.flags.issue, input.retryOptsOverride) } } };
+			const vars = { first };
+			if (after !== void 0) vars.after = after;
+			if (issueIdFilter !== void 0) vars.filter = issueIdFilter;
+			const response = await withRateLimitRetry(() => client.client.rawRequest(query, vars), input.retryOptsOverride);
+			if (response.error ?? !response.data) {
+				const safeMessage = redact(response.error ?? "no data returned from Linear API");
+				const safeCause = response.error !== void 0 ? redact(response.error) : void 0;
+				throw LinearAgentError.linear.apiError({
+					message: safeMessage,
+					details: {
+						command: "comment list",
+						cause: safeCause
+					}
+				});
+			}
+			const conn = response.data.comments;
+			const nodes = conn?.nodes ?? [];
+			const pageInfoRaw = conn?.pageInfo;
+			const projected = nodes.map((node) => project(node, fields));
+			const complexity = getLastComplexity();
+			return {
+				data: projected,
+				meta: {
+					workspace: resolved.name,
+					workspaceSource: resolved.source,
+					pageInfo: {
+						hasNextPage: Boolean(pageInfoRaw?.hasNextPage),
+						endCursor: pageInfoRaw?.endCursor ?? null,
+						hasPreviousPage: Boolean(pageInfoRaw?.hasPreviousPage),
+						startCursor: pageInfoRaw?.startCursor ?? null
+					},
+					...complexity !== void 0 ? { complexity } : {}
+				}
+			};
+		});
+	}
+	return withFetchInterception(async () => {
+		let issueIdFilter;
+		if (input.flags.issue !== void 0 && input.flags.issue !== "") issueIdFilter = { issue: { id: { eq: await resolveIssueRefToUuid(client, input.flags.issue, input.retryOptsOverride) } } };
+		const commentsArgs = { first };
+		if (after !== void 0) commentsArgs.after = after;
+		if (issueIdFilter !== void 0) commentsArgs.filter = issueIdFilter;
+		const connection = await withRateLimitRetry(() => client.comments(commentsArgs), input.retryOptsOverride);
+		const projected = await Promise.all(connection.nodes.map(async (node) => {
+			return project(await hydrateForProjection(node, fields), fields);
+		}));
+		const complexity = getLastComplexity();
+		return {
+			data: projected,
+			meta: {
+				workspace: resolved.name,
+				workspaceSource: resolved.source,
+				pageInfo: {
+					hasNextPage: Boolean(connection.pageInfo?.hasNextPage),
+					endCursor: connection.pageInfo?.endCursor ?? null,
+					hasPreviousPage: Boolean(connection.pageInfo?.hasPreviousPage),
+					startCursor: connection.pageInfo?.startCursor ?? null
+				},
+				...complexity !== void 0 ? { complexity } : {}
+			}
+		};
+	});
+}
+/**
+* Resolve a user-typed issue ref (ENG-123 or UUID) to a UUID.
+* UUID path is a no-op (no SDK round-trip); identifier path uses the
+* team-key + number filter against client.issues.
+*/
+async function resolveIssueRefToUuid(client, ref, retryOpts) {
+	if (UUID_RE.test(ref)) return ref;
+	const m = ISSUE_IDENTIFIER_RE.exec(ref);
+	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 node = (await withRateLimitRetry(() => client.issues({
+		filter: {
+			team: { key: { eq: teamKey } },
+			number: { eq: number }
+		},
+		first: 1
+	}), retryOpts)).nodes[0];
+	if (!node) throw new LinearAgentError({
+		code: "ISSUE_NOT_FOUND",
+		message: `issue not found: ${ref}`,
+		details: { ref }
+	});
+	return node.id;
+}
+const RELATION_KEYS = new Set([
+	"user",
+	"issue",
+	"parent"
+]);
+async function hydrateForProjection(comment, spec) {
+	const needs = neededRelations(spec);
+	if (needs.size === 0) {
+		const out = {};
+		for (const k of Object.keys(comment)) if (!RELATION_KEYS.has(k)) out[k] = comment[k];
+		return out;
+	}
+	const hydrated = {};
+	for (const k of Object.keys(comment)) if (RELATION_KEYS.has(k)) {
+		if (needs.has(k)) {
+			const value = comment[k];
+			hydrated[k] = await resolveLazy(value);
+		}
+	} else hydrated[k] = comment[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;
+}
+function composeCommentListWithIncludes(fragmentText) {
+	return `
+    query CommentsWithIncludes($filter: CommentFilter, $first: Int!, $after: String) {
+      comments(filter: $filter, first: $first, after: $after) {
+        nodes {
+          id body bodyData editedAt createdAt updatedAt archivedAt url
+          user { id name email displayName }
+          issue { id identifier title }
+          parent { id }
+          ${fragmentText}
+        }
+        pageInfo { hasNextPage endCursor hasPreviousPage startCursor }
+      }
+    }
+  `.trim();
+}
+//#endregion
+export { commentListRuntime };

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

@@ -0,0 +1,93 @@
+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";
+//#region src/lib/comment-update-runtime.ts
+const NO_FIELDS_MESSAGE = "no fields to update -- pass --body";
+async function commentUpdateRuntime(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.body === void 0) throw new LinearAgentError({
+		code: "VALIDATION_NO_FIELDS",
+		message: NO_FIELDS_MESSAGE
+	});
+	const fields = parseFields(input.flags.fields ?? "defaults", "comment");
+	const client = (input.clientFactoryOverride ?? createLinearClient)(resolved);
+	return withFetchInterception(async () => {
+		const updateInput = { body: input.flags.body };
+		const payload = await withRateLimitRetry(() => client.updateComment(input.args.id, updateInput), input.retryOptsOverride);
+		if (!payload.success) throw LinearAgentError.linear.apiError({
+			message: "updateComment returned success=false",
+			details: { lastSyncId: payload.lastSyncId }
+		});
+		let updated;
+		if (payload.comment !== void 0) {
+			const c = await Promise.resolve(payload.comment);
+			if (c !== void 0 && c !== null) updated = c;
+		}
+		let data;
+		if (updated) data = project(await hydrateForProjection(updated, fields), fields);
+		else data = { id: input.args.id };
+		const complexity = getLastComplexity();
+		const meta = {
+			workspace: resolved.name,
+			workspaceSource: resolved.source,
+			...complexity !== void 0 ? { complexity } : {}
+		};
+		return {
+			data,
+			meta
+		};
+	});
+}
+const RELATION_KEYS = new Set([
+	"user",
+	"issue",
+	"parent"
+]);
+async function hydrateForProjection(comment, spec) {
+	const needs = neededRelations(spec);
+	if (needs.size === 0) {
+		const out = {};
+		for (const k of Object.keys(comment)) if (!RELATION_KEYS.has(k)) out[k] = comment[k];
+		return out;
+	}
+	const hydrated = {};
+	for (const k of Object.keys(comment)) if (RELATION_KEYS.has(k)) {
+		if (needs.has(k)) {
+			const value = comment[k];
+			hydrated[k] = await resolveLazy(value);
+		}
+	} else hydrated[k] = comment[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 { commentUpdateRuntime };

package/dist/lib/cycle-current-runtime.js

@@ -0,0 +1,90 @@
+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 { resolveTeamId } from "../core/resolvers/team.js";
+import "../core/resolvers/index.js";
+//#region src/lib/cycle-current-runtime.ts
+async function cycleCurrentRuntime(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
+	});
+	if (input.flags.team === void 0 || input.flags.team === "") throw new LinearAgentError({
+		code: "WORKFLOW_TEAM_REQUIRED",
+		message: "cycle current requires --team <key|id|name>"
+	});
+	const fields = parseFields(input.flags.fields ?? "defaults", "cycle");
+	const client = (input.clientFactoryOverride ?? createLinearClient)(resolved);
+	return withFetchInterception(async () => {
+		const workspaceKey = resolved.name ?? "_api-key-env_";
+		const teamRef = input.flags.team;
+		const teamId = await resolveTeamId(client, workspaceKey, teamRef, input.retryOptsOverride);
+		const team = await withRateLimitRetry(() => client.team(teamId), input.retryOptsOverride);
+		const current = (await withRateLimitRetry(() => team.cycles({
+			filter: { isActive: { eq: true } },
+			first: 1
+		}), input.retryOptsOverride)).nodes[0];
+		if (!current) throw new LinearAgentError({
+			code: "CYCLE_NOT_FOUND",
+			message: `no active cycle for team ${teamRef}`,
+			details: {
+				teamId,
+				requested: "current"
+			}
+		});
+		const data = project(await hydrateForProjection(current, fields), fields);
+		const complexity = getLastComplexity();
+		return {
+			data,
+			meta: {
+				workspace: resolved.name,
+				workspaceSource: resolved.source,
+				...complexity !== void 0 ? { complexity } : {}
+			}
+		};
+	});
+}
+const RELATION_KEYS = new Set(["team"]);
+async function hydrateForProjection(cycle, spec) {
+	const needs = neededRelations(spec);
+	if (needs.size === 0) {
+		const out = {};
+		for (const k of Object.keys(cycle)) if (!RELATION_KEYS.has(k)) out[k] = cycle[k];
+		return out;
+	}
+	const hydrated = {};
+	for (const k of Object.keys(cycle)) if (RELATION_KEYS.has(k)) {
+		if (needs.has(k)) {
+			const value = cycle[k];
+			hydrated[k] = await resolveLazy(value);
+		}
+	} else hydrated[k] = cycle[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 { cycleCurrentRuntime };

package/dist/lib/cycle-list-runtime.js

@@ -0,0 +1,151 @@
+import { LinearAgentError } from "../core/errors/error.js";
+import { redact } from "../core/redact/redact.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 { parsePagination } from "../core/pagination/flags.js";
+import "../core/pagination/index.js";
+import { validateAndMergeIncludes } from "./include-fragments.js";
+import { resolveTeamId } from "../core/resolvers/team.js";
+import "../core/resolvers/index.js";
+//#region src/lib/cycle-list-runtime.ts
+async function cycleListRuntime(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", "cycle");
+	const { first, after } = parsePagination({
+		...input.flags.limit !== void 0 ? { limit: input.flags.limit } : {},
+		...input.flags.cursor !== void 0 ? { cursor: input.flags.cursor } : {}
+	});
+	const client = (input.clientFactoryOverride ?? createLinearClient)(resolved);
+	const includes = input.flags.include ?? [];
+	if (includes.length > 0) {
+		const query = composeCycleListWithIncludes(validateAndMergeIncludes("cycle list", includes));
+		return withFetchInterception(async () => {
+			let filter;
+			if (input.flags.team !== void 0) filter = { team: { id: { eq: await resolveTeamId(client, resolved.name ?? "_api-key-env_", input.flags.team, input.retryOptsOverride) } } };
+			const vars = { first };
+			if (after !== void 0) vars.after = after;
+			if (filter !== void 0) vars.filter = filter;
+			const response = await withRateLimitRetry(() => client.client.rawRequest(query, vars), input.retryOptsOverride);
+			if (response.error ?? !response.data) {
+				const safeMessage = redact(response.error ?? "no data returned from Linear API");
+				const safeCause = response.error !== void 0 ? redact(response.error) : void 0;
+				throw LinearAgentError.linear.apiError({
+					message: safeMessage,
+					details: {
+						command: "cycle list",
+						cause: safeCause
+					}
+				});
+			}
+			const conn = response.data.cycles;
+			const nodes = conn?.nodes ?? [];
+			const pageInfoRaw = conn?.pageInfo;
+			const projected = nodes.map((node) => project(node, fields));
+			const complexity = getLastComplexity();
+			return {
+				data: projected,
+				meta: {
+					workspace: resolved.name,
+					workspaceSource: resolved.source,
+					pageInfo: {
+						hasNextPage: Boolean(pageInfoRaw?.hasNextPage),
+						endCursor: pageInfoRaw?.endCursor ?? null,
+						hasPreviousPage: Boolean(pageInfoRaw?.hasPreviousPage),
+						startCursor: pageInfoRaw?.startCursor ?? null
+					},
+					...complexity !== void 0 ? { complexity } : {}
+				}
+			};
+		});
+	}
+	return withFetchInterception(async () => {
+		const workspaceKey = resolved.name ?? "_api-key-env_";
+		let filter;
+		if (input.flags.team !== void 0) filter = { team: { id: { eq: await resolveTeamId(client, workspaceKey, input.flags.team, input.retryOptsOverride) } } };
+		const cyclesArgs = { first };
+		if (after !== void 0) cyclesArgs.after = after;
+		if (filter !== void 0) cyclesArgs.filter = filter;
+		const connection = await withRateLimitRetry(() => client.cycles(cyclesArgs), input.retryOptsOverride);
+		const projected = await Promise.all(connection.nodes.map(async (node) => {
+			return project(await hydrateForProjection(node, fields), fields);
+		}));
+		const complexity = getLastComplexity();
+		return {
+			data: projected,
+			meta: {
+				workspace: resolved.name,
+				workspaceSource: resolved.source,
+				pageInfo: {
+					hasNextPage: Boolean(connection.pageInfo?.hasNextPage),
+					endCursor: connection.pageInfo?.endCursor ?? null,
+					hasPreviousPage: Boolean(connection.pageInfo?.hasPreviousPage),
+					startCursor: connection.pageInfo?.startCursor ?? null
+				},
+				...complexity !== void 0 ? { complexity } : {}
+			}
+		};
+	});
+}
+const RELATION_KEYS = new Set(["team"]);
+async function hydrateForProjection(cycle, spec) {
+	const needs = neededRelations(spec);
+	if (needs.size === 0) {
+		const out = {};
+		for (const k of Object.keys(cycle)) if (!RELATION_KEYS.has(k)) out[k] = cycle[k];
+		return out;
+	}
+	const hydrated = {};
+	for (const k of Object.keys(cycle)) if (RELATION_KEYS.has(k)) {
+		if (needs.has(k)) {
+			const value = cycle[k];
+			hydrated[k] = await resolveLazy(value);
+		}
+	} else hydrated[k] = cycle[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;
+}
+function composeCycleListWithIncludes(fragmentText) {
+	return `
+    query CyclesWithIncludes($filter: CycleFilter, $first: Int!, $after: String) {
+      cycles(filter: $filter, first: $first, after: $after) {
+        nodes {
+          id number name description startsAt endsAt completedAt progress
+          isActive isPast isFuture isNext isPrevious
+          createdAt updatedAt archivedAt
+          team { id name key }
+          ${fragmentText}
+        }
+        pageInfo { hasNextPage endCursor hasPreviousPage startCursor }
+      }
+    }
+  `.trim();
+}
+//#endregion
+export { cycleListRuntime };