ai-dev-requirements 0.1.2

package/dist/index.cjs

@@ -0,0 +1,785 @@
+
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let node_fs = require("node:fs");
+let node_path = require("node:path");
+let _modelcontextprotocol_sdk_server_mcp_js = require("@modelcontextprotocol/sdk/server/mcp.js");
+let _modelcontextprotocol_sdk_server_stdio_js = require("@modelcontextprotocol/sdk/server/stdio.js");
+let node_crypto = require("node:crypto");
+node_crypto = __toESM(node_crypto);
+let zod_v4 = require("zod/v4");
+
+//#region src/utils/map-status.ts
+const ONES_STATUS_MAP = {
+	to_do: "open",
+	in_progress: "in_progress",
+	done: "done",
+	closed: "closed"
+};
+const ONES_PRIORITY_MAP = {
+	urgent: "critical",
+	high: "high",
+	normal: "medium",
+	medium: "medium",
+	low: "low"
+};
+const ONES_TYPE_MAP = {
+	demand: "feature",
+	需求: "feature",
+	task: "task",
+	任务: "task",
+	bug: "bug",
+	缺陷: "bug",
+	story: "story",
+	子任务: "task",
+	工单: "task",
+	测试任务: "task"
+};
+function mapOnesStatus(status) {
+	return ONES_STATUS_MAP[status.toLowerCase()] ?? "open";
+}
+function mapOnesPriority(priority) {
+	return ONES_PRIORITY_MAP[priority.toLowerCase()] ?? "medium";
+}
+function mapOnesType(type) {
+	return ONES_TYPE_MAP[type.toLowerCase()] ?? "task";
+}
+
+//#endregion
+//#region src/adapters/base.ts
+/**
+* Abstract base class for source adapters.
+* Each adapter implements platform-specific logic for fetching requirements.
+*/
+var BaseAdapter = class {
+	sourceType;
+	config;
+	resolvedAuth;
+	constructor(sourceType, config, resolvedAuth) {
+		this.sourceType = sourceType;
+		this.config = config;
+		this.resolvedAuth = resolvedAuth;
+	}
+};
+
+//#endregion
+//#region src/adapters/ones.ts
+const TASK_DETAIL_QUERY = `
+  query Task($key: Key) {
+    task(key: $key) {
+      key uuid number name
+      issueType { uuid name }
+      status { uuid name category }
+      priority { value }
+      assign { uuid name }
+      owner { uuid name }
+      project { uuid name }
+      parent { uuid number issueType { uuid name } }
+      relatedTasks {
+        uuid number name
+        issueType { uuid name }
+        status { uuid name category }
+        assign { uuid name }
+      }
+      relatedWikiPages {
+        uuid
+        title
+        referenceType
+        subReferenceType
+        errorMessage
+      }
+      relatedWikiPagesCount
+    }
+  }
+`;
+const SEARCH_TASKS_QUERY = `
+  query GROUP_TASK_DATA($groupBy: GroupBy, $groupOrderBy: OrderBy, $orderBy: OrderBy, $filterGroup: [Filter!], $search: Search, $pagination: Pagination, $limit: Int) {
+    buckets(groupBy: $groupBy, orderBy: $groupOrderBy, pagination: $pagination, filter: $search) {
+      key
+      tasks(filterGroup: $filterGroup, orderBy: $orderBy, limit: $limit, includeAncestors: { pathField: "path" }) {
+        key uuid number name
+        issueType { uuid name }
+        status { uuid name category }
+        priority { value }
+        assign { uuid name }
+        project { uuid name }
+      }
+    }
+  }
+`;
+const TASK_BY_NUMBER_QUERY = SEARCH_TASKS_QUERY;
+const DEFAULT_STATUS_NOT_IN = [
+	"FgMGkcaq",
+	"NvRwHBSo",
+	"Dn3k8ffK",
+	"TbmY2So5"
+];
+function base64Url(buffer) {
+	return buffer.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+}
+function getSetCookies(response) {
+	const headers = response.headers;
+	if (headers.getSetCookie) return headers.getSetCookie();
+	const raw = response.headers.get("set-cookie");
+	return raw ? [raw] : [];
+}
+function toRequirement(task, description = "") {
+	return {
+		id: task.uuid,
+		source: "ones",
+		title: `#${task.number} ${task.name}`,
+		description,
+		status: mapOnesStatus(task.status?.category ?? "to_do"),
+		priority: mapOnesPriority(task.priority?.value ?? "normal"),
+		type: mapOnesType(task.issueType?.name ?? "任务"),
+		labels: [],
+		reporter: "",
+		assignee: task.assign?.name ?? null,
+		createdAt: "",
+		updatedAt: "",
+		dueDate: null,
+		attachments: [],
+		raw: task
+	};
+}
+var OnesAdapter = class extends BaseAdapter {
+	session = null;
+	constructor(sourceType, config, resolvedAuth) {
+		super(sourceType, config, resolvedAuth);
+	}
+	/**
+	* ONES OAuth2 PKCE login flow.
+	* Reference: D:\company code\ones\packages\core\src\auth.ts
+	*/
+	async login() {
+		if (this.session && Date.now() < this.session.expiresAt) return this.session;
+		const baseUrl = this.config.apiBase;
+		const email = this.resolvedAuth.email;
+		const password = this.resolvedAuth.password;
+		if (!email || !password) throw new Error("ONES auth requires email and password (ones-pkce auth type)");
+		const certRes = await fetch(`${baseUrl}/identity/api/encryption_cert`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: "{}"
+		});
+		if (!certRes.ok) throw new Error(`ONES: Failed to get encryption cert: ${certRes.status}`);
+		const cert = await certRes.json();
+		const encryptedPassword = node_crypto.default.publicEncrypt({
+			key: cert.public_key,
+			padding: node_crypto.default.constants.RSA_PKCS1_PADDING
+		}, Buffer.from(password, "utf-8")).toString("base64");
+		const loginRes = await fetch(`${baseUrl}/identity/api/login`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({
+				email,
+				password: encryptedPassword
+			})
+		});
+		if (!loginRes.ok) {
+			const text = await loginRes.text().catch(() => "");
+			throw new Error(`ONES: Login failed: ${loginRes.status} ${text}`);
+		}
+		const cookies = getSetCookies(loginRes).map((cookie) => cookie.split(";")[0]).join("; ");
+		const loginData = await loginRes.json();
+		const orgUuid = this.config.options?.orgUuid;
+		let orgUser = loginData.org_users[0];
+		if (orgUuid) {
+			const match = loginData.org_users.find((u) => u.org_uuid === orgUuid);
+			if (match) orgUser = match;
+		}
+		const codeVerifier = base64Url(node_crypto.default.randomBytes(32));
+		const codeChallenge = base64Url(node_crypto.default.createHash("sha256").update(codeVerifier).digest());
+		const authorizeParams = new URLSearchParams({
+			client_id: "ones.v1",
+			scope: `openid offline_access ones:org:${orgUser.region_uuid}:${orgUser.org_uuid}:${orgUser.org_user.org_user_uuid}`,
+			response_type: "code",
+			code_challenge_method: "S256",
+			code_challenge: codeChallenge,
+			redirect_uri: `${baseUrl}/auth/authorize/callback`,
+			state: `org_uuid=${orgUser.org_uuid}`
+		});
+		const authorizeLocation = (await fetch(`${baseUrl}/identity/authorize`, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/x-www-form-urlencoded",
+				"Cookie": cookies
+			},
+			body: authorizeParams.toString(),
+			redirect: "manual"
+		})).headers.get("location");
+		if (!authorizeLocation) throw new Error("ONES: Authorize response missing location header");
+		const authRequestId = new URL(authorizeLocation).searchParams.get("id");
+		if (!authRequestId) throw new Error("ONES: Cannot parse auth_request_id from authorize redirect");
+		const finalizeRes = await fetch(`${baseUrl}/identity/api/auth_request/finalize`, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json;charset=UTF-8",
+				"Cookie": cookies
+			},
+			body: JSON.stringify({
+				auth_request_id: authRequestId,
+				region_uuid: orgUser.region_uuid,
+				org_uuid: orgUser.org_uuid,
+				org_user_uuid: orgUser.org_user.org_user_uuid
+			})
+		});
+		if (!finalizeRes.ok) {
+			const text = await finalizeRes.text().catch(() => "");
+			throw new Error(`ONES: Finalize failed: ${finalizeRes.status} ${text}`);
+		}
+		const callbackLocation = (await fetch(`${baseUrl}/identity/authorize/callback?id=${authRequestId}&lang=zh`, {
+			method: "GET",
+			headers: { Cookie: cookies },
+			redirect: "manual"
+		})).headers.get("location");
+		if (!callbackLocation) throw new Error("ONES: Callback response missing location header");
+		const code = new URL(callbackLocation).searchParams.get("code");
+		if (!code) throw new Error("ONES: Cannot parse authorization code from callback redirect");
+		const tokenRes = await fetch(`${baseUrl}/identity/oauth/token`, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/x-www-form-urlencoded",
+				"Cookie": cookies
+			},
+			body: new URLSearchParams({
+				grant_type: "authorization_code",
+				client_id: "ones.v1",
+				code,
+				code_verifier: codeVerifier,
+				redirect_uri: `${baseUrl}/auth/authorize/callback`
+			}).toString()
+		});
+		if (!tokenRes.ok) {
+			const text = await tokenRes.text().catch(() => "");
+			throw new Error(`ONES: Token exchange failed: ${tokenRes.status} ${text}`);
+		}
+		const token = await tokenRes.json();
+		const teamsRes = await fetch(`${baseUrl}/project/api/project/organization/${orgUser.org_uuid}/stamps/data?t=org_my_team`, {
+			method: "POST",
+			headers: {
+				"Authorization": `Bearer ${token.access_token}`,
+				"Content-Type": "application/json;charset=UTF-8"
+			},
+			body: JSON.stringify({ org_my_team: 0 })
+		});
+		if (!teamsRes.ok) throw new Error(`ONES: Failed to fetch teams: ${teamsRes.status}`);
+		const teams = (await teamsRes.json()).org_my_team?.teams ?? [];
+		const configTeamUuid = this.config.options?.teamUuid;
+		let teamUuid = teams[0]?.uuid;
+		if (configTeamUuid) {
+			const match = teams.find((t) => t.uuid === configTeamUuid);
+			if (match) teamUuid = match.uuid;
+		}
+		if (!teamUuid) throw new Error("ONES: No teams found for this user");
+		this.session = {
+			accessToken: token.access_token,
+			teamUuid,
+			orgUuid: orgUser.org_uuid,
+			expiresAt: Date.now() + (token.expires_in - 60) * 1e3
+		};
+		return this.session;
+	}
+	/**
+	* Execute a GraphQL query against ONES project API.
+	*/
+	async graphql(query, variables, tag) {
+		const session = await this.login();
+		const url = `${this.config.apiBase}/project/api/project/team/${session.teamUuid}/items/graphql${tag ? `?t=${encodeURIComponent(tag)}` : ""}`;
+		const response = await fetch(url, {
+			method: "POST",
+			headers: {
+				"Authorization": `Bearer ${session.accessToken}`,
+				"Content-Type": "application/json"
+			},
+			body: JSON.stringify({
+				query,
+				variables
+			})
+		});
+		if (!response.ok) {
+			const text = await response.text().catch(() => "");
+			throw new Error(`ONES GraphQL error: ${response.status} ${text}`);
+		}
+		return response.json();
+	}
+	/**
+	* Fetch task info via REST API (includes description/rich fields not available in GraphQL).
+	* Reference: ones/packages/core/src/tasks.ts → fetchTaskInfo
+	*/
+	async fetchTaskInfo(taskUuid) {
+		const session = await this.login();
+		const url = `${this.config.apiBase}/project/api/project/team/${session.teamUuid}/task/${taskUuid}/info`;
+		const response = await fetch(url, { headers: { Authorization: `Bearer ${session.accessToken}` } });
+		if (!response.ok) return {};
+		return response.json();
+	}
+	/**
+	* Fetch wiki page content via REST API.
+	* Endpoint: /wiki/api/wiki/team/{teamUuid}/online_page/{wikiUuid}/content
+	*/
+	async fetchWikiContent(wikiUuid) {
+		const session = await this.login();
+		const url = `${this.config.apiBase}/wiki/api/wiki/team/${session.teamUuid}/online_page/${wikiUuid}/content`;
+		const response = await fetch(url, { headers: { Authorization: `Bearer ${session.accessToken}` } });
+		if (!response.ok) return "";
+		return (await response.json()).content ?? "";
+	}
+	/**
+	* Fetch a single task by UUID or number (e.g. "#95945" or "95945").
+	* If a number is given, searches first to resolve the UUID.
+	*/
+	async getRequirement(params) {
+		let taskUuid = params.id;
+		const numMatch = taskUuid.match(/^#?(\d+)$/);
+		if (numMatch) {
+			const taskNumber = Number.parseInt(numMatch[1], 10);
+			const found = ((await this.graphql(TASK_BY_NUMBER_QUERY, {
+				groupBy: { tasks: {} },
+				groupOrderBy: null,
+				orderBy: { createTime: "DESC" },
+				filterGroup: [{ number_in: [taskNumber] }],
+				search: null,
+				pagination: {
+					limit: 10,
+					preciseCount: false
+				},
+				limit: 10
+			}, "group-task-data")).data?.buckets?.flatMap((b) => b.tasks ?? []) ?? []).find((t) => t.number === taskNumber);
+			if (!found) throw new Error(`ONES: Task #${taskNumber} not found in current team`);
+			taskUuid = found.uuid;
+		}
+		const task = (await this.graphql(TASK_DETAIL_QUERY, { key: `task-${taskUuid}` }, "Task")).data?.task;
+		if (!task) throw new Error(`ONES: Task "${taskUuid}" not found`);
+		const wikiPages = task.relatedWikiPages ?? [];
+		const wikiContents = await Promise.all(wikiPages.filter((w) => !w.errorMessage).map(async (wiki) => {
+			const content = await this.fetchWikiContent(wiki.uuid);
+			return {
+				title: wiki.title,
+				uuid: wiki.uuid,
+				content
+			};
+		}));
+		const parts = [];
+		parts.push(`# #${task.number} ${task.name}`);
+		parts.push("");
+		parts.push(`- **Type**: ${task.issueType?.name ?? "Unknown"}`);
+		parts.push(`- **Status**: ${task.status?.name ?? "Unknown"}`);
+		parts.push(`- **Assignee**: ${task.assign?.name ?? "Unassigned"}`);
+		if (task.owner?.name) parts.push(`- **Owner**: ${task.owner.name}`);
+		if (task.project?.name) parts.push(`- **Project**: ${task.project.name}`);
+		parts.push(`- **UUID**: ${task.uuid}`);
+		if (task.relatedTasks?.length) {
+			parts.push("");
+			parts.push("## Related Tasks");
+			for (const related of task.relatedTasks) parts.push(`- #${related.number} ${related.name} [${related.issueType?.name}] (${related.status?.name})`);
+		}
+		if (task.parent?.uuid) {
+			parts.push("");
+			parts.push("## Parent Task");
+			parts.push(`- UUID: ${task.parent.uuid}`);
+			if (task.parent.number) parts.push(`- Number: #${task.parent.number}`);
+		}
+		if (wikiContents.length > 0) {
+			parts.push("");
+			parts.push("---");
+			parts.push("");
+			parts.push("## Requirement Documents");
+			for (const wiki of wikiContents) {
+				parts.push("");
+				parts.push(`### ${wiki.title}`);
+				parts.push("");
+				if (wiki.content) parts.push(wiki.content);
+				else parts.push("(No content available)");
+			}
+		}
+		return toRequirement(task, parts.join("\n"));
+	}
+	/**
+	* Search tasks assigned to current user via GraphQL.
+	* Uses keyword-based local filtering (matching ONES reference implementation).
+	*/
+	async searchRequirements(params) {
+		const page = params.page ?? 1;
+		const pageSize = params.pageSize ?? 50;
+		let tasks = (await this.graphql(SEARCH_TASKS_QUERY, {
+			groupBy: { tasks: {} },
+			groupOrderBy: null,
+			orderBy: {
+				position: "ASC",
+				createTime: "DESC"
+			},
+			filterGroup: [{
+				assign_in: ["${currentUser}"],
+				status_notIn: DEFAULT_STATUS_NOT_IN
+			}],
+			search: null,
+			pagination: {
+				limit: pageSize * page,
+				preciseCount: false
+			},
+			limit: 1e3
+		}, "group-task-data")).data?.buckets?.flatMap((b) => b.tasks ?? []) ?? [];
+		if (params.query) {
+			const keyword = params.query;
+			const lower = keyword.toLowerCase();
+			const numMatch = keyword.match(/^#?(\d+)$/);
+			if (numMatch) tasks = tasks.filter((t) => t.number === Number.parseInt(numMatch[1], 10));
+			else tasks = tasks.filter((t) => t.name.toLowerCase().includes(lower));
+		}
+		const total = tasks.length;
+		const start = (page - 1) * pageSize;
+		return {
+			items: tasks.slice(start, start + pageSize).map((t) => toRequirement(t)),
+			total,
+			page,
+			pageSize
+		};
+	}
+};
+
+//#endregion
+//#region src/adapters/index.ts
+const ADAPTER_MAP = { ones: OnesAdapter };
+/**
+* Factory function to create the appropriate adapter based on source type.
+*/
+function createAdapter(sourceType, config, resolvedAuth) {
+	const AdapterClass = ADAPTER_MAP[sourceType];
+	if (!AdapterClass) throw new Error(`Unsupported source type: "${sourceType}". Supported: ${Object.keys(ADAPTER_MAP).join(", ")}`);
+	return new AdapterClass(sourceType, config, resolvedAuth);
+}
+
+//#endregion
+//#region src/config/loader.ts
+const AuthSchema = zod_v4.z.discriminatedUnion("type", [
+	zod_v4.z.object({
+		type: zod_v4.z.literal("token"),
+		tokenEnv: zod_v4.z.string()
+	}),
+	zod_v4.z.object({
+		type: zod_v4.z.literal("basic"),
+		usernameEnv: zod_v4.z.string(),
+		passwordEnv: zod_v4.z.string()
+	}),
+	zod_v4.z.object({
+		type: zod_v4.z.literal("oauth2"),
+		clientIdEnv: zod_v4.z.string(),
+		clientSecretEnv: zod_v4.z.string(),
+		tokenUrl: zod_v4.z.string().url()
+	}),
+	zod_v4.z.object({
+		type: zod_v4.z.literal("cookie"),
+		cookieEnv: zod_v4.z.string()
+	}),
+	zod_v4.z.object({
+		type: zod_v4.z.literal("custom"),
+		headerName: zod_v4.z.string(),
+		valueEnv: zod_v4.z.string()
+	}),
+	zod_v4.z.object({
+		type: zod_v4.z.literal("ones-pkce"),
+		emailEnv: zod_v4.z.string(),
+		passwordEnv: zod_v4.z.string()
+	})
+]);
+const SourceConfigSchema = zod_v4.z.object({
+	enabled: zod_v4.z.boolean(),
+	apiBase: zod_v4.z.string().url(),
+	auth: AuthSchema,
+	headers: zod_v4.z.record(zod_v4.z.string(), zod_v4.z.string()).optional(),
+	options: zod_v4.z.record(zod_v4.z.string(), zod_v4.z.unknown()).optional()
+});
+const SourcesSchema = zod_v4.z.object({ ones: SourceConfigSchema.optional() });
+const McpConfigSchema = zod_v4.z.object({
+	sources: SourcesSchema,
+	defaultSource: zod_v4.z.enum(["ones"]).optional()
+});
+const CONFIG_FILENAME = ".requirements-mcp.json";
+/**
+* Search for config file starting from `startDir` and walking up to the root.
+*/
+function findConfigFile(startDir) {
+	let dir = (0, node_path.resolve)(startDir);
+	while (true) {
+		const candidate = (0, node_path.resolve)(dir, CONFIG_FILENAME);
+		if ((0, node_fs.existsSync)(candidate)) return candidate;
+		const parent = (0, node_path.dirname)(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	return null;
+}
+/**
+* Resolve environment variable references in auth config.
+* Reads actual env var values for fields ending with "Env".
+*/
+function resolveAuthEnv(auth) {
+	const resolved = {};
+	for (const [key, value] of Object.entries(auth)) {
+		if (key === "type") continue;
+		if (key.endsWith("Env") && typeof value === "string") {
+			const envValue = process.env[value];
+			if (!envValue) throw new Error(`Environment variable "${value}" is not set (required by auth.${key})`);
+			const resolvedKey = key.slice(0, -3);
+			resolved[resolvedKey] = envValue;
+		} else if (typeof value === "string") resolved[key] = value;
+	}
+	return resolved;
+}
+/**
+* Load and validate the MCP config file.
+* Searches from `startDir` (defaults to cwd) upward.
+*/
+function loadConfig(startDir) {
+	const dir = startDir ?? process.cwd();
+	const configPath = findConfigFile(dir);
+	if (!configPath) throw new Error(`Config file "${CONFIG_FILENAME}" not found. Searched from "${dir}" to root. Create one based on .requirements-mcp.json.example`);
+	const raw = (0, node_fs.readFileSync)(configPath, "utf-8");
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		throw new Error(`Invalid JSON in ${configPath}`);
+	}
+	const result = McpConfigSchema.safeParse(parsed);
+	if (!result.success) throw new Error(`Invalid config in ${configPath}:\n${result.error.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n")}`);
+	const config = result.data;
+	const sources = [];
+	for (const [type, sourceConfig] of Object.entries(config.sources)) if (sourceConfig && sourceConfig.enabled) {
+		const resolvedAuth = resolveAuthEnv(sourceConfig.auth);
+		sources.push({
+			type,
+			config: sourceConfig,
+			resolvedAuth
+		});
+	}
+	if (sources.length === 0) throw new Error("No enabled sources found in config. Enable at least one source.");
+	return {
+		config,
+		sources,
+		configPath
+	};
+}
+
+//#endregion
+//#region src/tools/get-requirement.ts
+const GetRequirementSchema = zod_v4.z.object({
+	id: zod_v4.z.string().describe("The requirement/issue ID"),
+	source: zod_v4.z.string().optional().describe("Source to fetch from. If omitted, uses the default source.")
+});
+async function handleGetRequirement(input, adapters, defaultSource) {
+	const sourceType = input.source ?? defaultSource;
+	if (!sourceType) throw new Error("No source specified and no default source configured");
+	const adapter = adapters.get(sourceType);
+	if (!adapter) throw new Error(`Source "${sourceType}" is not configured. Available: ${[...adapters.keys()].join(", ")}`);
+	return { content: [{
+		type: "text",
+		text: formatRequirement(await adapter.getRequirement({ id: input.id }))
+	}] };
+}
+function formatRequirement(req) {
+	const lines = [
+		`# ${req.title}`,
+		"",
+		`- **ID**: ${req.id}`,
+		`- **Source**: ${req.source}`,
+		`- **Status**: ${req.status}`,
+		`- **Priority**: ${req.priority}`,
+		`- **Type**: ${req.type}`,
+		`- **Assignee**: ${req.assignee ?? "Unassigned"}`,
+		`- **Reporter**: ${req.reporter || "Unknown"}`
+	];
+	if (req.createdAt) lines.push(`- **Created**: ${req.createdAt}`);
+	if (req.updatedAt) lines.push(`- **Updated**: ${req.updatedAt}`);
+	if (req.dueDate) lines.push(`- **Due**: ${req.dueDate}`);
+	if (req.labels.length > 0) lines.push(`- **Labels**: ${req.labels.join(", ")}`);
+	lines.push("", "## Description", "", req.description || "_No description_");
+	if (req.attachments.length > 0) {
+		lines.push("", "## Attachments");
+		for (const att of req.attachments) lines.push(`- [${att.name}](${att.url}) (${att.mimeType}, ${att.size} bytes)`);
+	}
+	return lines.join("\n");
+}
+
+//#endregion
+//#region src/tools/list-sources.ts
+async function handleListSources(adapters, config) {
+	const lines = ["# Configured Sources", ""];
+	if (adapters.size === 0) {
+		lines.push("No sources configured.");
+		return { content: [{
+			type: "text",
+			text: lines.join("\n")
+		}] };
+	}
+	for (const [type, adapter] of adapters) {
+		const isDefault = config.defaultSource === type;
+		const sourceConfig = config.sources[adapter.sourceType];
+		lines.push(`## ${type}${isDefault ? " (default)" : ""}`);
+		lines.push(`- **API Base**: ${sourceConfig?.apiBase ?? "N/A"}`);
+		lines.push(`- **Auth Type**: ${sourceConfig?.auth.type ?? "N/A"}`);
+		lines.push("");
+	}
+	if (config.defaultSource) lines.push(`> Default source: **${config.defaultSource}**`);
+	return { content: [{
+		type: "text",
+		text: lines.join("\n")
+	}] };
+}
+
+//#endregion
+//#region src/tools/search-requirements.ts
+const SearchRequirementsSchema = zod_v4.z.object({
+	query: zod_v4.z.string().describe("Search keywords"),
+	source: zod_v4.z.string().optional().describe("Source to search. If omitted, searches the default source."),
+	page: zod_v4.z.number().int().min(1).optional().describe("Page number (default: 1)"),
+	pageSize: zod_v4.z.number().int().min(1).max(50).optional().describe("Results per page (default: 20, max: 50)")
+});
+async function handleSearchRequirements(input, adapters, defaultSource) {
+	const sourceType = input.source ?? defaultSource;
+	if (!sourceType) throw new Error("No source specified and no default source configured");
+	const adapter = adapters.get(sourceType);
+	if (!adapter) throw new Error(`Source "${sourceType}" is not configured. Available: ${[...adapters.keys()].join(", ")}`);
+	const result = await adapter.searchRequirements({
+		query: input.query,
+		page: input.page,
+		pageSize: input.pageSize
+	});
+	const lines = [`Found **${result.total}** results (page ${result.page}/${Math.ceil(result.total / result.pageSize) || 1}):`, ""];
+	for (const item of result.items) {
+		lines.push(`### ${item.id}: ${item.title}`);
+		lines.push(`- Status: ${item.status} | Priority: ${item.priority} | Type: ${item.type}`);
+		lines.push(`- Assignee: ${item.assignee ?? "Unassigned"}`);
+		if (item.description) {
+			const desc = item.description.length > 200 ? `${item.description.slice(0, 200)}...` : item.description;
+			lines.push(`- ${desc}`);
+		}
+		lines.push("");
+	}
+	return { content: [{
+		type: "text",
+		text: lines.join("\n")
+	}] };
+}
+
+//#endregion
+//#region src/index.ts
+/**
+* Load .env file into process.env (if it exists).
+* Searches from cwd upward, same as config loader.
+*/
+function loadEnvFile() {
+	let dir = process.cwd();
+	while (true) {
+		const envPath = (0, node_path.resolve)(dir, ".env");
+		if ((0, node_fs.existsSync)(envPath)) {
+			const content = (0, node_fs.readFileSync)(envPath, "utf-8");
+			for (const line of content.split("\n")) {
+				const trimmed = line.trim();
+				if (!trimmed || trimmed.startsWith("#")) continue;
+				const eqIndex = trimmed.indexOf("=");
+				if (eqIndex === -1) continue;
+				const key = trimmed.slice(0, eqIndex).trim();
+				let value = trimmed.slice(eqIndex + 1).trim();
+				if (value.startsWith("\"") && value.endsWith("\"") || value.startsWith("'") && value.endsWith("'")) value = value.slice(1, -1);
+				if (!process.env[key]) process.env[key] = value;
+			}
+			return;
+		}
+		const parent = (0, node_path.dirname)(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+}
+async function main() {
+	loadEnvFile();
+	let config;
+	try {
+		config = loadConfig();
+	} catch (err) {
+		console.error(`[requirements-mcp] ${err.message}`);
+		process.exit(1);
+	}
+	const adapters = /* @__PURE__ */ new Map();
+	for (const source of config.sources) {
+		const adapter = createAdapter(source.type, source.config, source.resolvedAuth);
+		adapters.set(source.type, adapter);
+	}
+	const server = new _modelcontextprotocol_sdk_server_mcp_js.McpServer({
+		name: "ai-dev-requirements",
+		version: "0.1.0"
+	});
+	server.tool("get_requirement", "Fetch a single requirement/issue by its ID from a configured source (ONES)", GetRequirementSchema.shape, async (params) => {
+		try {
+			return await handleGetRequirement(params, adapters, config.config.defaultSource);
+		} catch (err) {
+			return {
+				content: [{
+					type: "text",
+					text: `Error: ${err.message}`
+				}],
+				isError: true
+			};
+		}
+	});
+	server.tool("search_requirements", "Search for requirements/issues by keywords across a configured source", SearchRequirementsSchema.shape, async (params) => {
+		try {
+			return await handleSearchRequirements(params, adapters, config.config.defaultSource);
+		} catch (err) {
+			return {
+				content: [{
+					type: "text",
+					text: `Error: ${err.message}`
+				}],
+				isError: true
+			};
+		}
+	});
+	server.tool("list_sources", "List all configured requirement sources and their status", {}, async () => {
+		try {
+			return await handleListSources(adapters, config.config);
+		} catch (err) {
+			return {
+				content: [{
+					type: "text",
+					text: `Error: ${err.message}`
+				}],
+				isError: true
+			};
+		}
+	});
+	const transport = new _modelcontextprotocol_sdk_server_stdio_js.StdioServerTransport();
+	await server.connect(transport);
+}
+main().catch((err) => {
+	console.error("[requirements-mcp] Fatal error:", err);
+	process.exit(1);
+});
+
+//#endregion