@overdeck/desktop 0.49.1 → 0.49.2

package/server/{dist-src-BM9eudEd.js → factory-BrdqXBeK.js}

@@ -1,4 +1,279 @@
 import { n as __esmMin, t as __commonJSMin } from "./rolldown-runtime-DNCzzKnI.js";
+import { $r as GitHubApiError, ci as init_errors, p as loadConfigSync, t as init_config_yaml, ti as LinearApiError } from "./config-yaml-D9nfpEx1.js";
+import { a as TrackerAuthError, i as NotImplementedError, o as init_interface, r as IssueNotFoundError } from "./rally-api-CqAIJ8RX.js";
+import { n as init_rally, t as RallyTracker } from "./rally-bQpBzUNf.js";
+import { Effect } from "effect";
+import { LinearClient } from "@linear/sdk";
+//#region ../../lib/tracker/linear.ts
+/**
+* Linear Issue Tracker Adapter
+*
+* Implements IssueTracker interface for Linear.
+*/
+/**
+* Wrap an arbitrary Linear SDK promise as an Effect that emits LinearApiError
+* on failure.
+*/
+function linearCall(operation, thunk) {
+	return Effect.tryPromise({
+		try: thunk,
+		catch: (cause) => {
+			return new LinearApiError({
+				operation,
+				message: cause?.message ?? String(cause),
+				cause
+			});
+		}
+	});
+}
+var STATE_MAP, UUID_RE, LinearTracker;
+var init_linear = __esmMin((() => {
+	init_interface();
+	init_errors();
+	STATE_MAP = {
+		backlog: "open",
+		unstarted: "open",
+		started: "in_progress",
+		completed: "closed",
+		canceled: "closed"
+	};
+	UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+	LinearTracker = class {
+		name = "linear";
+		client;
+		defaultTeam;
+		constructor(apiKey, options) {
+			if (!apiKey) throw new TrackerAuthError({
+				tracker: "linear",
+				message: "API key is required"
+			});
+			this.client = new LinearClient({ apiKey });
+			this.defaultTeam = options?.team;
+		}
+		listIssues(filters) {
+			const team = filters?.team ?? this.defaultTeam;
+			const self = this;
+			return linearCall("listIssues", async () => {
+				const limit = filters?.limit;
+				const filter = {
+					team: team ? { key: { eq: team } } : void 0,
+					state: filters?.state ? { type: { eq: self.reverseMapState(filters.state) } } : filters?.includeClosed ? void 0 : { type: { neq: "completed" } },
+					labels: filters?.labels?.length ? { name: { in: filters.labels } } : void 0,
+					assignee: filters?.assignee ? { name: { containsIgnoreCase: filters.assignee } } : void 0
+				};
+				const query = `query ListIssues($filter: IssueFilter, $first: Int!, $after: String) {
+        issues(filter: $filter, first: $first, after: $after) {
+          nodes {
+            id identifier title description url priority dueDate createdAt updatedAt
+            state { type } assignee { name } labels { nodes { name } }
+          }
+          pageInfo { hasNextPage endCursor }
+        }
+      }`;
+				const nodes = [];
+				let after = null;
+				do {
+					const first = Math.min(limit === void 0 ? 50 : limit - nodes.length, 50);
+					const page = (await self.client.client.rawRequest(query, {
+						filter,
+						first,
+						after
+					})).data?.issues;
+					if (!page?.nodes || !Array.isArray(page.nodes)) throw new Error("Incomplete Linear issues response");
+					nodes.push(...page.nodes);
+					after = page.pageInfo?.hasNextPage && page.pageInfo.endCursor ? page.pageInfo.endCursor : null;
+				} while (after !== null && (limit === void 0 || nodes.length < limit));
+				return (limit === void 0 ? nodes : nodes.slice(0, limit)).map((node) => self.normalizeListedIssue(node));
+			});
+		}
+		getIssue(id) {
+			const self = this;
+			return linearCall("getIssue", async () => {
+				if (UUID_RE.test(id) || /^([A-Z]+)-(\d+)$/i.test(id)) {
+					const issue = await self.client.issue(id);
+					if (issue) return await self.normalizeIssue(issue);
+				}
+				return null;
+			}).pipe(Effect.flatMap((issue) => issue ? Effect.succeed(issue) : Effect.fail(new IssueNotFoundError({
+				id,
+				tracker: "linear"
+			}))), Effect.catchTag("LinearApiError", () => Effect.fail(new IssueNotFoundError({
+				id,
+				tracker: "linear"
+			}))));
+		}
+		updateIssue(id, update) {
+			const self = this;
+			return self.getIssue(id).pipe(Effect.flatMap((issue) => {
+				const updatePayload = {};
+				if (update.title !== void 0) updatePayload.title = update.title;
+				if (update.description !== void 0) updatePayload.description = update.description;
+				if (update.priority !== void 0) updatePayload.priority = update.priority;
+				if (update.dueDate !== void 0) updatePayload.dueDate = update.dueDate;
+				const stateTransition = update.state !== void 0 ? self.transitionIssue(id, update.state) : Effect.succeed(void 0);
+				const applyDirect = Object.keys(updatePayload).length > 0 ? linearCall("updateIssue", () => self.client.updateIssue(issue.id, updatePayload)).pipe(Effect.asVoid) : Effect.succeed(void 0);
+				return stateTransition.pipe(Effect.flatMap(() => applyDirect), Effect.flatMap(() => self.getIssue(id)));
+			}));
+		}
+		createIssue(newIssue) {
+			const team = newIssue.team ?? this.defaultTeam;
+			const self = this;
+			if (!team) return Effect.fail(new LinearApiError({
+				operation: "createIssue",
+				message: "Team is required to create an issue"
+			}));
+			return linearCall("createIssue:lookupTeam", () => self.client.teams({ filter: { key: { eq: team } } })).pipe(Effect.flatMap((teams) => {
+				if (teams.nodes.length === 0) return Effect.fail(new LinearApiError({
+					operation: "createIssue",
+					message: `Team not found: ${team}`
+				}));
+				const teamId = teams.nodes[0].id;
+				return linearCall("createIssue", () => self.client.createIssue({
+					teamId,
+					title: newIssue.title,
+					description: newIssue.description,
+					priority: newIssue.priority,
+					dueDate: newIssue.dueDate
+				})).pipe(Effect.flatMap((result) => linearCall("createIssue:fetchCreated", async () => {
+					const created = await result.issue;
+					if (!created) throw new Error("Failed to create issue");
+					return await self.normalizeIssue(created);
+				})));
+			}));
+		}
+		getComments(issueId) {
+			const self = this;
+			return linearCall("getComments", async () => {
+				return (await (await self.client.issue(issueId)).comments()).nodes.map((c) => ({
+					id: c.id,
+					issueId,
+					body: c.body,
+					author: c.user?.then((u) => u?.name ?? "Unknown"),
+					createdAt: c.createdAt.toISOString(),
+					updatedAt: c.updatedAt.toISOString()
+				}));
+			});
+		}
+		addComment(issueId, body) {
+			const self = this;
+			return linearCall("addComment", async () => {
+				const comment = await (await self.client.createComment({
+					issueId,
+					body
+				})).comment;
+				if (!comment) throw new Error("Failed to create comment");
+				return {
+					id: comment.id,
+					issueId,
+					body: comment.body,
+					author: "Overdeck",
+					createdAt: comment.createdAt.toISOString(),
+					updatedAt: comment.updatedAt.toISOString()
+				};
+			});
+		}
+		transitionIssue(id, state) {
+			const self = this;
+			return linearCall("transitionIssue:resolve", async () => {
+				let linearIssue;
+				if (UUID_RE.test(id)) linearIssue = await self.client.issue(id);
+				else {
+					const results = await self.client.searchIssues(id, { first: 1 });
+					if (results.nodes.length > 0) linearIssue = results.nodes[0];
+					else return null;
+				}
+				return linearIssue;
+			}).pipe(Effect.flatMap((linearIssue) => {
+				if (!linearIssue) return Effect.fail(new IssueNotFoundError({
+					id,
+					tracker: "linear"
+				}));
+				return linearCall("transitionIssue:apply", async () => {
+					const team = await linearIssue.team;
+					if (!team) throw new Error("Could not determine issue team");
+					const states = await team.states();
+					let targetState;
+					if (state === "in_review") {
+						targetState = states.nodes.find((s) => s.name.toLowerCase() === "in review");
+						if (!targetState) {
+							targetState = states.nodes.filter((s) => s.type === "started").sort((a, b) => (a.position ?? 0) - (b.position ?? 0))[0];
+							if (!targetState) throw new Error("No \"In Review\" or \"started\" state found in Linear");
+						}
+					} else {
+						const targetStateType = self.reverseMapState(state);
+						targetState = states.nodes.filter((s) => s.type === targetStateType).sort((a, b) => (a.position ?? 0) - (b.position ?? 0))[0];
+						if (!targetState) throw new Error(`No state found matching type: ${targetStateType}`);
+					}
+					await self.client.updateIssue(linearIssue.id, { stateId: targetState.id });
+				});
+			}));
+		}
+		linkPR(issueId, prUrl) {
+			const self = this;
+			return self.getIssue(issueId).pipe(Effect.flatMap((issue) => linearCall("linkPR", () => self.client.createAttachment({
+				issueId: issue.id,
+				title: "Pull Request",
+				url: prUrl
+			}))), Effect.asVoid);
+		}
+		getChildIssues(_parentId) {
+			return Effect.succeed([]);
+		}
+		/** Map a raw-GraphQL listed node (relations already inlined) — no lazy SDK loads. */
+		normalizeListedIssue(node) {
+			return {
+				id: node.id,
+				ref: node.identifier,
+				title: node.title,
+				description: node.description ?? "",
+				state: this.mapState(node.state?.type ?? "backlog"),
+				labels: node.labels?.nodes?.flatMap((label) => label.name ? [label.name] : []) ?? [],
+				assignee: node.assignee?.name ?? void 0,
+				url: node.url,
+				tracker: "linear",
+				priority: node.priority ?? void 0,
+				dueDate: node.dueDate ?? void 0,
+				createdAt: node.createdAt,
+				updatedAt: node.updatedAt
+			};
+		}
+		async normalizeIssue(linearIssue) {
+			const state = await linearIssue.state;
+			const assignee = await linearIssue.assignee;
+			const labels = await linearIssue.labels();
+			let dueDate;
+			if (linearIssue.dueDate) dueDate = linearIssue.dueDate instanceof Date ? linearIssue.dueDate.toISOString() : String(linearIssue.dueDate);
+			return {
+				id: linearIssue.id,
+				ref: linearIssue.identifier,
+				title: linearIssue.title,
+				description: linearIssue.description ?? "",
+				state: this.mapState(state?.type ?? "backlog"),
+				labels: labels?.nodes?.map((l) => l.name) ?? [],
+				assignee: assignee?.name,
+				url: linearIssue.url,
+				tracker: "linear",
+				priority: linearIssue.priority,
+				dueDate,
+				createdAt: linearIssue.createdAt instanceof Date ? linearIssue.createdAt.toISOString() : String(linearIssue.createdAt),
+				updatedAt: linearIssue.updatedAt instanceof Date ? linearIssue.updatedAt.toISOString() : String(linearIssue.updatedAt)
+			};
+		}
+		mapState(linearState) {
+			return STATE_MAP[linearState] ?? "open";
+		}
+		reverseMapState(state) {
+			switch (state) {
+				case "open": return "unstarted";
+				case "in_progress":
+				case "in_review": return "started";
+				case "closed": return "completed";
+				default: return "unstarted";
+			}
+		}
+	};
+}));
+//#endregion
 //#region ../../../node_modules/.bun/universal-user-agent@7.0.3/node_modules/universal-user-agent/index.js
 function getUserAgent() {
 	if (typeof navigator === "object" && "userAgent" in navigator) return navigator.userAgent;
@@ -2481,6 +2756,443 @@ var init_dist_src = __esmMin((() => {
 	Octokit = Octokit$1.plugin(requestLog, legacyRestEndpointMethods, paginateRest).defaults({ userAgent: `octokit-rest.js/${VERSION}` });
 }));
 //#endregion
-export { init_dist_src as n, Octokit as t };
+//#region ../../lib/tracker/github.ts
+/**
+* GitHub Issues Tracker Adapter
+*
+* Implements IssueTracker interface for GitHub Issues.
+*/
+/**
+* Extract issue number from various formats: "300", "#300", "PAN-300"
+*/
+function parseIssueNumber(id) {
+	const match = id.match(/(\d+)$/);
+	return match ? parseInt(match[1], 10) : NaN;
+}
+/**
+* Wrap an Octokit promise in an Effect that emits typed errors.
+*
+* Treats HTTP 404 as IssueNotFoundError; everything else becomes
+* GitHubApiError carrying the status code (or 0 for network failures).
+*/
+function octokitToProgram(operation, resourceId, thunk) {
+	return Effect.tryPromise({
+		try: thunk,
+		catch: (cause) => {
+			const status = cause?.status ?? 0;
+			if (status === 404) return new IssueNotFoundError({
+				id: resourceId,
+				tracker: "github"
+			});
+			return new GitHubApiError({
+				operation,
+				status,
+				message: cause?.message ?? String(cause),
+				cause
+			});
+		}
+	});
+}
+var GitHubTracker;
+var init_github = __esmMin((() => {
+	init_dist_src();
+	init_interface();
+	init_errors();
+	GitHubTracker = class {
+		name = "github";
+		octokit;
+		owner;
+		repo;
+		constructor(token, owner, repo) {
+			if (!token) throw new TrackerAuthError({
+				tracker: "github",
+				message: "Token is required"
+			});
+			if (!owner || !repo) throw new Error("GitHub owner and repo are required");
+			this.octokit = new Octokit({ auth: token });
+			this.owner = owner;
+			this.repo = repo;
+		}
+		listIssues(filters) {
+			const state = this.mapStateToGitHub(filters?.state);
+			return Effect.tryPromise({
+				try: () => this.octokit.issues.listForRepo({
+					owner: this.owner,
+					repo: this.repo,
+					state: filters?.includeClosed ? "all" : state,
+					labels: filters?.labels?.join(",") || void 0,
+					assignee: filters?.assignee || void 0,
+					per_page: filters?.limit ?? 50
+				}),
+				catch: (cause) => {
+					return new GitHubApiError({
+						operation: "listIssues",
+						status: cause?.status ?? 0,
+						message: cause?.message ?? String(cause),
+						cause
+					});
+				}
+			}).pipe(Effect.map((response) => {
+				return response.data.filter((item) => !item.pull_request).map((issue) => this.normalizeIssue(issue));
+			}));
+		}
+		getIssue(id) {
+			const issueNumber = parseIssueNumber(id);
+			if (isNaN(issueNumber)) return Effect.fail(new IssueNotFoundError({
+				id,
+				tracker: "github"
+			}));
+			return octokitToProgram("getIssue", id, () => this.octokit.issues.get({
+				owner: this.owner,
+				repo: this.repo,
+				issue_number: issueNumber
+			})).pipe(Effect.map(({ data: issue }) => this.normalizeIssue(issue)));
+		}
+		updateIssue(id, update) {
+			const issueNumber = parseIssueNumber(id);
+			const updatePayload = {};
+			if (update.title !== void 0) updatePayload.title = update.title;
+			if (update.description !== void 0) updatePayload.body = update.description;
+			if (update.state !== void 0) updatePayload.state = update.state === "closed" ? "closed" : "open";
+			if (update.labels !== void 0) updatePayload.labels = update.labels;
+			if (update.assignee !== void 0) updatePayload.assignees = update.assignee ? [update.assignee] : [];
+			return octokitToProgram("updateIssue", id, () => this.octokit.issues.update({
+				owner: this.owner,
+				repo: this.repo,
+				issue_number: issueNumber,
+				...updatePayload
+			})).pipe(Effect.flatMap(() => this.getIssue(id)));
+		}
+		createIssue(newIssue) {
+			return Effect.tryPromise({
+				try: () => this.octokit.issues.create({
+					owner: this.owner,
+					repo: this.repo,
+					title: newIssue.title,
+					body: newIssue.description,
+					labels: newIssue.labels,
+					assignees: newIssue.assignee ? [newIssue.assignee] : void 0
+				}),
+				catch: (cause) => {
+					return new GitHubApiError({
+						operation: "createIssue",
+						status: cause?.status ?? 0,
+						message: cause?.message ?? String(cause),
+						cause
+					});
+				}
+			}).pipe(Effect.map(({ data: issue }) => this.normalizeIssue(issue)));
+		}
+		getComments(issueId) {
+			const issueNumber = parseIssueNumber(issueId);
+			return Effect.tryPromise({
+				try: () => this.octokit.issues.listComments({
+					owner: this.owner,
+					repo: this.repo,
+					issue_number: issueNumber
+				}),
+				catch: (cause) => {
+					return new GitHubApiError({
+						operation: "getComments",
+						status: cause?.status ?? 0,
+						message: cause?.message ?? String(cause),
+						cause
+					});
+				}
+			}).pipe(Effect.map(({ data: comments }) => comments.map((c) => ({
+				id: String(c.id),
+				issueId,
+				body: c.body ?? "",
+				author: c.user?.login ?? "Unknown",
+				createdAt: c.created_at,
+				updatedAt: c.updated_at
+			}))));
+		}
+		addComment(issueId, body) {
+			const issueNumber = parseIssueNumber(issueId);
+			return Effect.tryPromise({
+				try: () => this.octokit.issues.createComment({
+					owner: this.owner,
+					repo: this.repo,
+					issue_number: issueNumber,
+					body
+				}),
+				catch: (cause) => {
+					return new GitHubApiError({
+						operation: "addComment",
+						status: cause?.status ?? 0,
+						message: cause?.message ?? String(cause),
+						cause
+					});
+				}
+			}).pipe(Effect.map(({ data: comment }) => ({
+				id: String(comment.id),
+				issueId,
+				body: comment.body ?? "",
+				author: comment.user?.login ?? "Unknown",
+				createdAt: comment.created_at,
+				updatedAt: comment.updated_at
+			})));
+		}
+		transitionIssue(id, state) {
+			const issueNumber = parseIssueNumber(id);
+			const owner = this.owner;
+			const repo = this.repo;
+			const octokit = this.octokit;
+			const self = this;
+			const addLabels = (labels) => Effect.tryPromise({
+				try: () => octokit.issues.addLabels({
+					owner,
+					repo,
+					issue_number: issueNumber,
+					labels
+				}),
+				catch: (cause) => {
+					return new GitHubApiError({
+						operation: "addLabels",
+						status: cause?.status ?? 0,
+						message: cause?.message ?? String(cause),
+						cause
+					});
+				}
+			});
+			const removeLabelSilent = (name) => Effect.tryPromise({
+				try: () => octokit.issues.removeLabel({
+					owner,
+					repo,
+					issue_number: issueNumber,
+					name
+				}),
+				catch: () => new GitHubApiError({
+					operation: "removeLabel",
+					status: 0,
+					message: "remove failed"
+				})
+			}).pipe(Effect.orElseSucceed(() => void 0));
+			const ensureLabelExists = (name, description, color) => Effect.tryPromise({
+				try: () => octokit.issues.getLabel({
+					owner,
+					repo,
+					name
+				}),
+				catch: () => new GitHubApiError({
+					operation: "getLabel",
+					status: 404,
+					message: "label missing"
+				})
+			}).pipe(Effect.matchEffect({
+				onFailure: () => Effect.tryPromise({
+					try: () => octokit.issues.createLabel({
+						owner,
+						repo,
+						name,
+						description,
+						color
+					}),
+					catch: () => new GitHubApiError({
+						operation: "createLabel",
+						status: 0,
+						message: "create failed"
+					})
+				}).pipe(Effect.orElseSucceed(() => void 0)),
+				onSuccess: () => Effect.succeed(void 0)
+			}));
+			if (state === "in_progress") return self.getIssue(id).pipe(Effect.flatMap((issue) => {
+				const currentLabels = new Set(issue.labels ?? []);
+				return ensureLabelExists("in-progress", "In progress", "0075ca").pipe(Effect.flatMap(() => addLabels(["in-progress"])), Effect.flatMap(() => Effect.forEach([
+					"in-review",
+					"planned",
+					"in-planning",
+					"review-ready",
+					"done",
+					"merged",
+					"verifying-on-main",
+					"needs-close-out",
+					"closed-out"
+				].filter((label) => currentLabels.has(label)), (label) => removeLabelSilent(label), { concurrency: 1 })), Effect.asVoid);
+			}));
+			if (state === "in_review") return ensureLabelExists("in-review", "In review", "e4e669").pipe(Effect.flatMap(() => addLabels(["in-review"])), Effect.flatMap(() => removeLabelSilent("in-progress")), Effect.asVoid);
+			return self.getIssue(id).pipe(Effect.flatMap((issue) => {
+				const labelsToRemove = ["in-progress", "in-review"].filter((l) => issue.labels?.includes(l));
+				return Effect.forEach(labelsToRemove, (label) => removeLabelSilent(label), { concurrency: 1 }).pipe(Effect.flatMap(() => self.updateIssue(id, { state })));
+			}), Effect.asVoid);
+		}
+		linkPR(issueId, prUrl) {
+			return this.addComment(issueId, `Linked Pull Request: ${prUrl}`).pipe(Effect.asVoid);
+		}
+		getChildIssues(_parentId) {
+			return Effect.succeed([]);
+		}
+		normalizeIssue(ghIssue) {
+			const labels = ghIssue.labels.map((l) => typeof l === "string" ? l : l.name);
+			return {
+				id: String(ghIssue.id),
+				ref: `#${ghIssue.number}`,
+				title: ghIssue.title,
+				description: ghIssue.body ?? "",
+				state: this.mapStateFromGitHub(ghIssue.state, labels),
+				labels,
+				author: ghIssue.user?.login,
+				assignee: ghIssue.assignee?.login,
+				url: ghIssue.html_url,
+				tracker: "github",
+				priority: void 0,
+				dueDate: void 0,
+				createdAt: ghIssue.created_at,
+				updatedAt: ghIssue.updated_at
+			};
+		}
+		mapStateFromGitHub(ghState, labels = []) {
+			if (ghState === "closed") return "closed";
+			if (labels.includes("in-progress")) return "in_progress";
+			return "open";
+		}
+		mapStateToGitHub(state) {
+			if (!state) return "open";
+			if (state === "closed") return "closed";
+			return "open";
+		}
+	};
+}));
+//#endregion
+//#region ../../lib/tracker/gitlab.ts
+/**
+* GitLab Issues Tracker Adapter (Stub)
+*
+* Placeholder implementation for GitLab Issues support.
+* Full implementation will use @gitbeaker/rest.
+*/
+var notImplemented, GitLabTracker;
+var init_gitlab = __esmMin((() => {
+	init_interface();
+	notImplemented = (feature) => Effect.fail(new NotImplementedError({ feature }));
+	GitLabTracker = class {
+		name = "gitlab";
+		constructor(token, projectId) {
+			this.token = token;
+			this.projectId = projectId;
+			this.token;
+			this.projectId;
+		}
+		listIssues(_filters) {
+			return notImplemented("GitLab tracker is not yet implemented. Coming soon!");
+		}
+		getIssue(_id) {
+			return notImplemented("GitLab tracker is not yet implemented. Coming soon!");
+		}
+		updateIssue(_id, _update) {
+			return notImplemented("GitLab tracker is not yet implemented. Coming soon!");
+		}
+		createIssue(_issue) {
+			return notImplemented("GitLab tracker is not yet implemented. Coming soon!");
+		}
+		getComments(_issueId) {
+			return notImplemented("GitLab tracker is not yet implemented. Coming soon!");
+		}
+		addComment(_issueId, _body) {
+			return notImplemented("GitLab tracker is not yet implemented. Coming soon!");
+		}
+		transitionIssue(_id, _state) {
+			return notImplemented("GitLab tracker is not yet implemented. Coming soon!");
+		}
+		linkPR(_issueId, _prUrl) {
+			return notImplemented("GitLab tracker is not yet implemented. Coming soon!");
+		}
+		getChildIssues(_parentId) {
+			return Effect.succeed([]);
+		}
+	};
+}));
+//#endregion
+//#region ../../lib/tracker/factory.ts
+/**
+* Get tracker API key from config.yaml (Settings page).
+* This is checked FIRST — env vars are the fallback, not the other way around.
+*/
+function getTrackerKeyFromConfig(trackerType) {
+	try {
+		const { config: yamlConfig } = loadConfigSync();
+		return yamlConfig.trackerKeys[trackerType];
+	} catch {
+		return;
+	}
+}
+/**
+* Create a tracker instance from configuration.
+* Priority: config.yaml (Settings) > environment variable > custom env var name
+*/
+function createTracker(config) {
+	switch (config.type) {
+		case "linear": {
+			const configKey = getTrackerKeyFromConfig("linear");
+			const envKey = config.apiKeyEnv ? process.env[config.apiKeyEnv] : process.env.LINEAR_API_KEY;
+			const apiKey = configKey || envKey;
+			if (!apiKey) throw new TrackerAuthError({
+				tracker: "linear",
+				message: `API key not found. Configure in Settings or set ${config.apiKeyEnv ?? "LINEAR_API_KEY"} environment variable.`
+			});
+			return new LinearTracker(apiKey, { team: config.team });
+		}
+		case "github": {
+			const configKey = getTrackerKeyFromConfig("github");
+			const envToken = config.tokenEnv ? process.env[config.tokenEnv] : process.env.GITHUB_TOKEN;
+			const token = configKey || envToken;
+			if (!token) throw new TrackerAuthError({
+				tracker: "github",
+				message: `Token not found. Configure in Settings or set ${config.tokenEnv ?? "GITHUB_TOKEN"} environment variable.`
+			});
+			if (!config.owner || !config.repo) throw new Error("GitHub tracker requires owner and repo configuration");
+			return new GitHubTracker(token, config.owner, config.repo);
+		}
+		case "gitlab": {
+			const configKey = getTrackerKeyFromConfig("gitlab");
+			const envToken = config.tokenEnv ? process.env[config.tokenEnv] : process.env.GITLAB_TOKEN;
+			const token = configKey || envToken;
+			if (!token) throw new TrackerAuthError({
+				tracker: "gitlab",
+				message: `Token not found. Configure in Settings or set ${config.tokenEnv ?? "GITLAB_TOKEN"} environment variable.`
+			});
+			if (!config.projectId) throw new Error("GitLab tracker requires projectId configuration");
+			return new GitLabTracker(token, config.projectId);
+		}
+		case "rally": {
+			const configKey = getTrackerKeyFromConfig("rally");
+			const envKey = config.apiKeyEnv ? process.env[config.apiKeyEnv] : process.env.RALLY_API_KEY;
+			const apiKey = configKey || envKey;
+			if (!apiKey) throw new TrackerAuthError({
+				tracker: "rally",
+				message: `API key not found. Configure in Settings or set ${config.apiKeyEnv ?? "RALLY_API_KEY"} environment variable.`
+			});
+			return new RallyTracker({
+				apiKey,
+				server: config.server,
+				workspace: config.workspace,
+				project: config.project
+			});
+		}
+		default: throw new Error(`Unknown tracker type: ${config.type}`);
+	}
+}
+/**
+* Create tracker from trackers configuration section
+*/
+function createTrackerFromConfig(trackersConfig, trackerType) {
+	const config = trackersConfig[trackerType];
+	if (!config) throw new Error(`No configuration found for tracker: ${trackerType}. Add [trackers.${trackerType}] to config.`);
+	return createTracker({
+		...config,
+		type: trackerType
+	});
+}
+var init_factory = __esmMin((() => {
+	init_interface();
+	init_linear();
+	init_github();
+	init_gitlab();
+	init_rally();
+	init_config_yaml();
+}));
+//#endregion
+export { init_dist_src as a, Octokit as i, createTrackerFromConfig as n, LinearTracker as o, init_factory as r, init_linear as s, createTracker as t };
 
-//# sourceMappingURL=dist-src-BM9eudEd.js.map
+//# sourceMappingURL=factory-BrdqXBeK.js.map