linmux 0.1.0

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

@@ -0,0 +1,97 @@
+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 { TEAM_KEY_RE, UUID_RE } from "./filter-heuristics.js";
+//#region src/lib/label-list-runtime.ts
+async function labelListRuntime(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", "label");
+	const { first, after } = parsePagination({
+		...input.flags.limit !== void 0 ? { limit: input.flags.limit } : {},
+		...input.flags.cursor !== void 0 ? { cursor: input.flags.cursor } : {}
+	});
+	let filter;
+	if (input.flags.team !== void 0 && input.flags.team !== "") filter = buildTeamFilter(input.flags.team);
+	const client = (input.clientFactoryOverride ?? createLinearClient)(resolved);
+	return withFetchInterception(async () => {
+		const args = { first };
+		if (after !== void 0) args.after = after;
+		if (filter !== void 0) args.filter = filter;
+		const connection = await withRateLimitRetry(() => client.issueLabels(args), 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 } : {}
+			}
+		};
+	});
+}
+function buildTeamFilter(t) {
+	if (UUID_RE.test(t)) return { team: { id: { eq: t } } };
+	if (TEAM_KEY_RE.test(t)) return { team: { key: { eq: t.toUpperCase() } } };
+	return { team: { name: { eq: t } } };
+}
+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 { labelListRuntime };

package/dist/lib/levenshtein.js

@@ -0,0 +1,42 @@
+//#region src/lib/levenshtein.ts
+/**
+* Levenshtein distance and closest-name suggester.
+*
+* Extracted from `raw-runtime.ts` (Phase 3) for shared use by:
+*   - `raw-runtime.ts` — "did you mean X?" suggestions on RAW_OPERATION_NOT_FOUND
+*   - `describe-runtime.ts` (Phase 4) — DESCRIBE_COMMAND_NOT_FOUND suggestions
+*
+* The Int32Array flat-row-major implementation avoids biome's `noNonNullAssertion`
+* warnings that a 2D array approach would trigger.
+*/
+/**
+* Return the top `limit` closest names to `missing` by Levenshtein distance.
+* Comparison is case-insensitive so "issues" matches "Issues" with distance 0.
+*/
+function suggestClosest(missing, names, limit = 3) {
+	return names.map((n) => ({
+		name: n,
+		d: levenshtein(missing.toLowerCase(), n.toLowerCase())
+	})).sort((a, b) => a.d - b.d).slice(0, limit).map((x) => x.name);
+}
+/**
+* Simple iterative Levenshtein distance.
+* Uses flat typed array to avoid biome noNonNullAssertion warnings on 2D indexing.
+*/
+function levenshtein(a, b) {
+	const m = a.length;
+	const n = b.length;
+	const dp = new Int32Array((m + 1) * (n + 1));
+	for (let i = 0; i <= m; i++) dp[i * (n + 1)] = i;
+	for (let j = 0; j <= n; j++) dp[j] = j;
+	for (let i = 1; i <= m; i++) for (let j = 1; j <= n; j++) {
+		const sub = a[i - 1] === b[j - 1] ? 0 : 1;
+		const del = (dp[(i - 1) * (n + 1) + j] ?? i) + 1;
+		const ins = (dp[i * (n + 1) + (j - 1)] ?? j) + 1;
+		const rep = (dp[(i - 1) * (n + 1) + (j - 1)] ?? i + j) + sub;
+		dp[i * (n + 1) + j] = Math.min(del, ins, rep);
+	}
+	return dp[m * (n + 1) + n] ?? 0;
+}
+//#endregion
+export { levenshtein, suggestClosest };

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

@@ -0,0 +1,38 @@
+import { CURATED_REGISTRY, getRawRegistryView } from "./introspection-registry.js";
+//#region src/lib/list-tools-runtime.ts
+/**
+* list-tools runtime — Phase 4 PLAN 04-02, INT-01.
+*
+* Pure data assembly from CURATED_REGISTRY + OPERATION_REGISTRY. Zero network
+* calls, zero workspace resolution. All data originates from committed static
+* constants (threat T-04-02-S, T-04-02-T).
+*
+* Two-export pattern (S1): named `listToolsRuntime` export + default oclif class
+* lives in src/commands/list-tools.ts.
+*/
+async function listToolsRuntime(_args) {
+	const curated = CURATED_REGISTRY.map((entry) => ({
+		id: entry.id,
+		summary: entry.summary,
+		flags: entry.flags,
+		...entry.raw_equivalent !== void 0 ? { raw_equivalent: entry.raw_equivalent } : {}
+	}));
+	const raw = getRawRegistryView().map((entry) => ({
+		name: entry.name,
+		kind: entry.kind
+	})).sort((a, b) => a.name.localeCompare(b.name));
+	return {
+		ok: true,
+		data: {
+			curated,
+			raw,
+			counts: {
+				curated: curated.length,
+				raw: raw.length
+			}
+		},
+		meta: { command: "list-tools" }
+	};
+}
+//#endregion
+export { listToolsRuntime };

package/dist/lib/me-runtime.js

@@ -0,0 +1,55 @@
+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";
+//#region src/lib/me-runtime.ts
+async function meRuntime(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", "user");
+	const client = (input.clientFactoryOverride ?? createLinearClient)(resolved);
+	return withFetchInterception(async () => {
+		const user = await withRateLimitRetry(() => Promise.resolve(client.viewer), input.retryOptsOverride);
+		const org = await withRateLimitRetry(() => Promise.resolve(user.organization), input.retryOptsOverride);
+		const data = {
+			user: project({
+				id: user.id,
+				name: user.name,
+				email: user.email,
+				displayName: user.displayName,
+				admin: user.admin,
+				isMe: user.isMe,
+				active: user.active,
+				avatarUrl: user.avatarUrl
+			}, fields),
+			organization: {
+				id: org.id,
+				name: org.name,
+				urlKey: org.urlKey
+			}
+		};
+		const complexity = getLastComplexity();
+		return {
+			data,
+			meta: {
+				workspace: resolved.name,
+				workspaceSource: resolved.source,
+				...complexity !== void 0 ? { complexity } : {}
+			}
+		};
+	});
+}
+//#endregion
+export { meRuntime };

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

@@ -0,0 +1,103 @@
+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 { resolveTeamId } from "../core/resolvers/team.js";
+import "../core/resolvers/index.js";
+import { resolveAssignee } from "./issue-create-runtime.js";
+//#region src/lib/project-create-runtime.ts
+async function projectCreateRuntime(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.teams === void 0 || input.flags.teams === "") throw LinearAgentError.usage("--teams is required (comma-separated team keys/UUIDs/names)");
+	const teamRefs = input.flags.teams.split(",").map((s) => s.trim()).filter(Boolean);
+	if (teamRefs.length === 0) throw LinearAgentError.usage("--teams is required (comma-separated team keys/UUIDs/names; got no valid entries)");
+	const name = input.flags.name;
+	const fields = parseFields(input.flags.fields ?? "defaults", "project");
+	const client = (input.clientFactoryOverride ?? createLinearClient)(resolved);
+	return withFetchInterception(async () => {
+		const workspaceKey = resolved.name ?? "_api-key-env_";
+		const flags = input.flags;
+		const [teamIds, leadId] = await Promise.all([Promise.all(teamRefs.map((t) => resolveTeamId(client, workspaceKey, t, input.retryOptsOverride))), flags.lead !== void 0 ? resolveAssignee(client, flags.lead, input.retryOptsOverride) : Promise.resolve(void 0)]);
+		const createInput = {
+			name,
+			teamIds
+		};
+		if (flags.description !== void 0) createInput.description = flags.description;
+		if (flags.state !== void 0) createInput.state = flags.state;
+		if (leadId !== void 0) createInput.leadId = leadId;
+		if (flags.startDate !== void 0) createInput.startDate = flags.startDate;
+		if (flags.targetDate !== void 0) createInput.targetDate = flags.targetDate;
+		const payload = await withRateLimitRetry(() => client.createProject(createInput), input.retryOptsOverride);
+		if (!payload.success) throw LinearAgentError.linear.apiError({
+			message: "createProject returned success=false",
+			details: { lastSyncId: payload.lastSyncId }
+		});
+		let created;
+		if (payload.project !== void 0) {
+			const p = await Promise.resolve(payload.project);
+			if (p !== void 0 && p !== null) created = p;
+		}
+		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(["lead", "creator"]);
+async function hydrateForProjection(proj, spec) {
+	const needs = neededRelations(spec);
+	if (needs.size === 0) {
+		const out = {};
+		for (const k of Object.keys(proj)) if (!RELATION_KEYS.has(k)) out[k] = proj[k];
+		return out;
+	}
+	const hydrated = {};
+	for (const k of Object.keys(proj)) if (RELATION_KEYS.has(k)) {
+		if (needs.has(k)) {
+			const value = proj[k];
+			hydrated[k] = await resolveLazy(value);
+		}
+	} else hydrated[k] = proj[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 { projectCreateRuntime };

package/dist/lib/project-get-runtime.js

@@ -0,0 +1,134 @@
+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 { UUID_RE } from "./filter-heuristics.js";
+import { validateAndMergeIncludes } from "./include-fragments.js";
+import { resolveProjectId } from "../core/resolvers/project.js";
+import "../core/resolvers/index.js";
+//#region src/lib/project-get-runtime.ts
+async function projectGetRuntime(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", "project");
+	const client = (input.clientFactoryOverride ?? createLinearClient)(resolved);
+	const includes = input.flags.include ?? [];
+	if (includes.length > 0) {
+		const query = composeProjectGetWithIncludes(validateAndMergeIncludes("project get", includes));
+		return withFetchInterception(async () => {
+			const ref = input.args.ref;
+			const workspaceKey = resolved.name ?? "_api-key-env_";
+			const projectId = UUID_RE.test(ref) ? ref : await resolveProjectId(client, workspaceKey, ref, input.retryOptsOverride);
+			const response = await withRateLimitRetry(() => client.client.rawRequest(query, { id: projectId }), 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: "project get",
+						cause: safeCause
+					}
+				});
+			}
+			const projectData = response.data.project;
+			if (!projectData) throw new LinearAgentError({
+				code: "PROJECT_NOT_FOUND",
+				message: `project not found: ${ref}`,
+				details: { ref }
+			});
+			const data = project(projectData, fields);
+			const complexity = getLastComplexity();
+			return {
+				data,
+				meta: {
+					workspace: resolved.name,
+					workspaceSource: resolved.source,
+					...complexity !== void 0 ? { complexity } : {}
+				}
+			};
+		});
+	}
+	return withFetchInterception(async () => {
+		const ref = input.args.ref;
+		const workspaceKey = resolved.name ?? "_api-key-env_";
+		const projectId = UUID_RE.test(ref) ? ref : await resolveProjectId(client, workspaceKey, ref, input.retryOptsOverride);
+		const proj = await withRateLimitRetry(() => client.project(projectId), input.retryOptsOverride);
+		if (!proj) throw new LinearAgentError({
+			code: "PROJECT_NOT_FOUND",
+			message: `project not found: ${ref}`,
+			details: { ref }
+		});
+		const data = project(await hydrateForProjection(proj, fields), fields);
+		const complexity = getLastComplexity();
+		return {
+			data,
+			meta: {
+				workspace: resolved.name,
+				workspaceSource: resolved.source,
+				...complexity !== void 0 ? { complexity } : {}
+			}
+		};
+	});
+}
+const RELATION_KEYS = new Set(["lead", "creator"]);
+async function hydrateForProjection(proj, spec) {
+	const needs = neededRelations(spec);
+	if (needs.size === 0) {
+		const out = {};
+		for (const k of Object.keys(proj)) if (!RELATION_KEYS.has(k)) out[k] = proj[k];
+		return out;
+	}
+	const hydrated = {};
+	for (const k of Object.keys(proj)) if (RELATION_KEYS.has(k)) {
+		if (needs.has(k)) {
+			const value = proj[k];
+			hydrated[k] = await resolveLazy(value);
+		}
+	} else hydrated[k] = proj[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 composeProjectGetWithIncludes(fragmentText) {
+	return `
+    query ProjectWithIncludes($id: String!) {
+      project(id: $id) {
+        id name description state progress sortOrder
+        startDate targetDate startedAt completedAt canceledAt archivedAt
+        createdAt updatedAt
+        color icon slugId url
+        lead { id email name }
+        creator { id email name }
+        ${fragmentText}
+      }
+    }
+  `.trim();
+}
+//#endregion
+export { projectGetRuntime };

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

@@ -0,0 +1,84 @@
+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";
+//#region src/lib/project-list-runtime.ts
+async function projectListRuntime(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", "project");
+	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);
+	return withFetchInterception(async () => {
+		const projectsArgs = { first };
+		if (after !== void 0) projectsArgs.after = after;
+		const connection = await withRateLimitRetry(() => client.projects(projectsArgs), 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(["lead", "creator"]);
+async function hydrateForProjection(proj, spec) {
+	const needs = neededRelations(spec);
+	if (needs.size === 0) {
+		const out = {};
+		for (const k of Object.keys(proj)) if (!RELATION_KEYS.has(k)) out[k] = proj[k];
+		return out;
+	}
+	const hydrated = {};
+	for (const k of Object.keys(proj)) if (RELATION_KEYS.has(k)) {
+		if (needs.has(k)) {
+			const value = proj[k];
+			hydrated[k] = await resolveLazy(value);
+		}
+	} else hydrated[k] = proj[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 { projectListRuntime };

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

@@ -0,0 +1,110 @@
+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 { UUID_RE } from "./filter-heuristics.js";
+import { resolveProjectId } from "../core/resolvers/project.js";
+import "../core/resolvers/index.js";
+import { resolveAssignee } from "./issue-create-runtime.js";
+//#region src/lib/project-update-runtime.ts
+const NO_FIELDS_MESSAGE = "no fields to update -- pass at least one of --name, --description, --state, --lead, --start-date, --target-date";
+function hasAnyFieldFlag(flags) {
+	return flags.name !== void 0 || flags.description !== void 0 || flags.state !== void 0 || flags.lead !== void 0 || flags.startDate !== void 0 || flags.targetDate !== void 0;
+}
+async function projectUpdateRuntime(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", "project");
+	const client = (input.clientFactoryOverride ?? createLinearClient)(resolved);
+	return withFetchInterception(async () => {
+		const workspaceKey = resolved.name ?? "_api-key-env_";
+		const ref = input.args.ref;
+		const flags = input.flags;
+		const projectId = UUID_RE.test(ref) ? ref : await resolveProjectId(client, workspaceKey, ref, input.retryOptsOverride);
+		const updateInput = {};
+		if (flags.name !== void 0) updateInput.name = flags.name;
+		if (flags.description !== void 0) updateInput.description = flags.description;
+		if (flags.state !== void 0) updateInput.state = flags.state;
+		if (flags.startDate !== void 0) updateInput.startDate = flags.startDate;
+		if (flags.targetDate !== void 0) updateInput.targetDate = flags.targetDate;
+		if (flags.lead !== void 0) updateInput.leadId = await resolveAssignee(client, flags.lead, input.retryOptsOverride);
+		if (Object.keys(updateInput).length === 0) throw new LinearAgentError({
+			code: "VALIDATION_NO_FIELDS",
+			message: NO_FIELDS_MESSAGE
+		});
+		const payload = await withRateLimitRetry(() => client.updateProject(projectId, updateInput), input.retryOptsOverride);
+		if (!payload.success) throw LinearAgentError.linear.apiError({
+			message: "updateProject returned success=false",
+			details: { lastSyncId: payload.lastSyncId }
+		});
+		let updated;
+		if (payload.project !== void 0) {
+			const u = await Promise.resolve(payload.project);
+			if (u !== void 0 && u !== null) updated = u;
+		}
+		let data;
+		if (updated) data = project(await hydrateForProjection(updated, fields), fields);
+		else data = { id: projectId };
+		const complexity = getLastComplexity();
+		const meta = {
+			workspace: resolved.name,
+			workspaceSource: resolved.source,
+			...complexity !== void 0 ? { complexity } : {}
+		};
+		return {
+			data,
+			meta
+		};
+	});
+}
+const RELATION_KEYS = new Set(["lead", "creator"]);
+async function hydrateForProjection(proj, spec) {
+	const needs = neededRelations(spec);
+	if (needs.size === 0) {
+		const out = {};
+		for (const k of Object.keys(proj)) if (!RELATION_KEYS.has(k)) out[k] = proj[k];
+		return out;
+	}
+	const hydrated = {};
+	for (const k of Object.keys(proj)) if (RELATION_KEYS.has(k)) {
+		if (needs.has(k)) {
+			const value = proj[k];
+			hydrated[k] = await resolveLazy(value);
+		}
+	} else hydrated[k] = proj[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 { projectUpdateRuntime };