linmux 0.1.0

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

@@ -0,0 +1,55 @@
+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 { TEAM_KEY_RE, UUID_RE } from "./filter-heuristics.js";
+//#region src/lib/team-get-runtime.ts
+async function teamGetRuntime(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", "team");
+	const client = (input.clientFactoryOverride ?? createLinearClient)(resolved);
+	return withFetchInterception(async () => {
+		const ref = input.args.ref;
+		let team;
+		if (UUID_RE.test(ref)) team = await withRateLimitRetry(() => client.team(ref), input.retryOptsOverride);
+		else if (TEAM_KEY_RE.test(ref)) team = (await withRateLimitRetry(() => client.teams({
+			filter: { key: { eq: ref.toUpperCase() } },
+			first: 1
+		}), input.retryOptsOverride)).nodes[0];
+		else team = (await withRateLimitRetry(() => client.teams({
+			filter: { name: { eq: ref } },
+			first: 1
+		}), input.retryOptsOverride)).nodes[0];
+		if (!team) throw new LinearAgentError({
+			code: "TEAM_NOT_FOUND",
+			message: `team not found: ${ref}`,
+			details: { ref }
+		});
+		const data = project(team, fields);
+		const complexity = getLastComplexity();
+		return {
+			data,
+			meta: {
+				workspace: resolved.name,
+				workspaceSource: resolved.source,
+				...complexity !== void 0 ? { complexity } : {}
+			}
+		};
+	});
+}
+//#endregion
+export { teamGetRuntime };

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

@@ -0,0 +1,52 @@
+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/team-list-runtime.ts
+async function teamListRuntime(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", "team");
+	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 teamsArgs = { first };
+		if (after !== void 0) teamsArgs.after = after;
+		const connection = await withRateLimitRetry(() => client.teams(teamsArgs), input.retryOptsOverride);
+		const projected = connection.nodes.map((node) => project(node, 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 } : {}
+			}
+		};
+	});
+}
+//#endregion
+export { teamListRuntime };

package/dist/lib/workspace-runtime.js

@@ -0,0 +1,112 @@
+import { LinearAgentError } from "../core/errors/error.js";
+import { exitCodeFor } from "../core/errors/exit-codes.js";
+import { failure, success } from "../core/output/envelope.js";
+import { format } from "../core/output/format.js";
+import "../core/output/index.js";
+import { classifySdkError } from "../core/transport/rate-limit.js";
+import "../core/transport/index.js";
+import { Flags } from "@oclif/core";
+//#region src/lib/workspace-runtime.ts
+/**
+* Shared runtime for workspace commands.
+*
+* Lives in `src/lib/` (not `src/commands/workspace/`) because oclif's manifest
+* generator scans every file under `src/commands/` as a command — a helper
+* file there would surface as `linmux workspace _shared`. The lib path
+* also matches `tsdown.config.ts`'s entry globs (commands + lib double-star
+* patterns) so the bundle layout stays predictable.
+*
+* Each oclif command file under `src/commands/workspace/` stays under ~50 LOC
+* by delegating envelope formatting, error wrapping, exit-code mapping, and
+* stdout/stderr writing to `runCommand` here. Tests call this helper (and the
+* per-command `run<Cmd>` wrappers in each file) directly without spawning a
+* subprocess.
+*
+* Flow:
+*   1. Caller invokes `runCommand({ commandPath, pretty, handler })`.
+*   2. Handler returns `{ data, meta }` for the success envelope.
+*   3. We wrap the result in the locked Phase 1 envelope (PLAN-01) via
+*      `success(data, { ...meta, command: commandPath })` and return
+*      `{ stdout, stderr?, exitCode: 0 }`.
+*   4. If the handler throws:
+*        - `LinearAgentError` → wrap as `failure(err, { command })`,
+*          exit code via `exitCodeFor(err.code)`.
+*        - Anything else → wrap as `LinearAgentError({ code: 'GENERIC_ERROR',
+*          message: 'Internal error', details: { cause: err.message } })`,
+*          exit code 1. The kernel-wide redactor in `format()` (PLAN-01) is
+*          the safety net that scrubs token-shaped substrings before stdout.
+*
+* This module imports from `@/core/output` and `@/core/errors` only — no
+* filesystem, no SDK, no oclif. The oclif `Command.run()` shim is the
+* thinnest possible glue (`process.stdout.write(out.stdout); process.exit(out.exitCode)`).
+*/
+const BASE_FLAGS = {
+	pretty: Flags.boolean({ description: "Human-readable output (default is JSON)" }),
+	quiet: Flags.boolean({ description: "Suppress meta block from success envelopes and pretty-mode banners (implies --no-meta)." }),
+	noMeta: Flags.boolean({
+		name: "no-meta",
+		aliases: ["no-meta"],
+		description: "Omit the meta block from success envelopes (smaller token footprint; failure envelopes unchanged)."
+	}),
+	retry: Flags.integer({
+		description: "Extra retries on transient errors (added on top of defaults). Min 0.",
+		min: 0,
+		default: 0
+	})
+};
+async function runCommand(args) {
+	const dropMeta = args.quiet === true || args.noMeta === true;
+	const effectivePretty = args.pretty && !dropMeta;
+	const extraAttempts = args.retry ?? 0;
+	const retryOptsOverride = extraAttempts > 0 && args.quiet !== true ? {
+		extraAttempts,
+		onRetry: (info) => {
+			process.stderr.write(`[retry ${info.attempt}/${info.total}] ${info.code}: backing off ${info.backoffMs}ms\n`);
+		}
+	} : { extraAttempts };
+	try {
+		const { data, meta } = await args.handler(retryOptsOverride);
+		const out = format(dropMeta ? {
+			$apiVersion: "1",
+			ok: true,
+			data
+		} : success(data, {
+			...meta,
+			command: args.commandPath
+		}), { pretty: effectivePretty });
+		return {
+			stdout: out.stdout,
+			stderr: out.stderr,
+			exitCode: 0
+		};
+	} catch (raw) {
+		const err = wrapAsLinearAgentError(raw);
+		const out = format(failure(err, { command: args.commandPath }), { pretty: effectivePretty });
+		return {
+			stdout: out.stdout,
+			stderr: out.stderr,
+			exitCode: exitCodeFor(err.code)
+		};
+	}
+}
+function wrapAsLinearAgentError(raw) {
+	if (raw instanceof LinearAgentError) return raw;
+	return new LinearAgentError({
+		code: "GENERIC_ERROR",
+		message: "Internal error",
+		details: { cause: raw instanceof Error ? raw.message : String(raw) }
+	});
+}
+/**
+* Read the env vars our commands consult. Pure for testability — callers
+* inject `process.env` so tests can pass a synthetic env without touching
+* the real one.
+*/
+function readEnv(env = process.env) {
+	const out = {};
+	if (env.LINEAR_WORKSPACE !== void 0) out.LINEAR_WORKSPACE = env.LINEAR_WORKSPACE;
+	if (env.LINEAR_API_KEY !== void 0) out.LINEAR_API_KEY = env.LINEAR_API_KEY;
+	return out;
+}
+//#endregion
+export { BASE_FLAGS, classifySdkError, readEnv, runCommand };