ai-dev-requirements 0.1.10 → 0.1.12

package/dist/index.mjs

@@ -116,6 +116,26 @@ const ISSUE_TYPES_QUERY = `
     }
   }
 `;
+const PROJECTS_QUERY = `
+  query Projects($groupBy: GroupBy, $orderBy: OrderBy, $pagination: Pagination, $projectOrderBy: OrderBy, $projectFilterGroup: [Filter!]) {
+    buckets(groupBy: $groupBy, orderBy: $orderBy, pagination: $pagination) {
+      key
+      projects(limit: 10000, orderBy: $projectOrderBy, filterGroup: $projectFilterGroup) {
+        key
+        uuid
+        name
+        identifier
+      }
+    }
+  }
+`;
+const ADD_MANHOUR_MUTATION = `
+  mutation AddManhour {
+    addManhour(mode: $mode, owner: $owner, task: $task, type: $type, start_time: $start_time, hours: $hours, description: $description, customData: $customData) {
+      key
+    }
+  }
+`;
 const TASK_BY_NUMBER_QUERY = SEARCH_TASKS_QUERY;
 const RELATED_TASKS_QUERY = `
   query Task($key: Key) {
@@ -303,6 +323,93 @@ function extractWikiPageUuidsFromText(text) {
 	for (const pattern of [/\/page\/([\w-]+)/g, /page=([\w-]+)/g]) for (const match of text.matchAll(pattern)) if (match[1]) uuids.add(match[1]);
 	return [...uuids];
 }
+function parseOnesWikiPageRoute(input) {
+	if (!input.includes("/wiki/")) return null;
+	const match = (() => {
+		try {
+			const parsed = new URL(input);
+			return `${parsed.pathname}${parsed.hash}${parsed.search}`;
+		} catch {
+			return input;
+		}
+	})().match(/\/team\/([^/?#]+)\/space\/[^/?#]+\/page\/([^/?#]+)/);
+	if (!match?.[1] || !match[2]) return null;
+	return {
+		teamUuid: decodeURIComponent(match[1]),
+		wikiUuid: decodeURIComponent(match[2])
+	};
+}
+function isOnesWikiUrlInput(input) {
+	return input.includes("/wiki/");
+}
+function parseAuthorizeRequestId(location) {
+	try {
+		const parsed = new URL(location);
+		return parsed.searchParams.get("auth_request_id") ?? parsed.searchParams.get("id");
+	} catch {
+		const match = location.match(/[?&](?:auth_request_id|id)=([^&#]+)/);
+		return match?.[1] ? decodeURIComponent(match[1]) : null;
+	}
+}
+function parseAuthorizationCode(location) {
+	try {
+		return new URL(location).searchParams.get("code");
+	} catch {
+		const match = location.match(/[?&]code=([^&#]+)/);
+		return match?.[1] ? decodeURIComponent(match[1]) : null;
+	}
+}
+function parseDisplayId(input) {
+	const match = input.trim().match(/^([a-z]\w*)-(\d+)$/i);
+	if (!match?.[1] || !match[2]) return null;
+	return {
+		identifier: match[1],
+		number: Number.parseInt(match[2], 10)
+	};
+}
+function isValidOnesDate(value) {
+	if (!/^\d{4}-\d{2}-\d{2}$/.test(value)) return false;
+	const [yearText, monthText, dayText] = value.split("-");
+	const year = Number.parseInt(yearText, 10);
+	const month = Number.parseInt(monthText, 10);
+	const day = Number.parseInt(dayText, 10);
+	const date = new Date(Date.UTC(year, month - 1, day));
+	return date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day;
+}
+function toOnesHours(hours) {
+	if (!Number.isFinite(hours) || hours <= 0) throw new Error("ONES: hours must be a positive number");
+	return Math.round(hours * 1e5);
+}
+function getTodayStartUnixSeconds() {
+	const now = /* @__PURE__ */ new Date();
+	const localStart = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+	return Math.floor(localStart.getTime() / 1e3);
+}
+function toLocalDateString(date) {
+	return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, "0")}-${String(date.getDate()).padStart(2, "0")}`;
+}
+function getLocalStartUnixSeconds(year, month, day) {
+	return Math.floor(new Date(year, month - 1, day).getTime() / 1e3);
+}
+function parseManhourDate(input) {
+	const value = input?.trim();
+	if (!value) return {
+		date: null,
+		startTime: getTodayStartUnixSeconds()
+	};
+	const fullDateMatch = value.match(/^(\d{4})-(\d{2})-(\d{2})$/);
+	const dayOnlyMatch = value.match(/^(\d{1,2})号?$/);
+	const now = /* @__PURE__ */ new Date();
+	const year = fullDateMatch ? Number.parseInt(fullDateMatch[1], 10) : now.getFullYear();
+	const month = fullDateMatch ? Number.parseInt(fullDateMatch[2], 10) : now.getMonth() + 1;
+	const day = fullDateMatch ? Number.parseInt(fullDateMatch[3], 10) : dayOnlyMatch ? Number.parseInt(dayOnlyMatch[1], 10) : NaN;
+	const parsed = new Date(year, month - 1, day);
+	if (!(Number.isInteger(day) && parsed.getFullYear() === year && parsed.getMonth() === month - 1 && parsed.getDate() === day)) throw new Error("ONES: date must be a valid YYYY-MM-DD date or day of current month");
+	return {
+		date: toLocalDateString(parsed),
+		startTime: getLocalStartUnixSeconds(year, month, day)
+	};
+}
 function htmlToPlainText(html) {
 	return html.replace(/<br\s*\/?>/gi, "\n").replace(/<\/p>/gi, "\n").replace(/<[^>]+>/g, "").replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/\n{3,}/g, "\n\n").trim();
 }
@@ -497,32 +604,35 @@ var OnesAdapter = class extends BaseAdapter {
 			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}`);
+		let code = parseAuthorizationCode(authorizeLocation);
+		if (!code) {
+			const authRequestId = parseAuthorizeRequestId(authorizeLocation);
+			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");
+			code = parseAuthorizationCode(callbackLocation);
 		}
-		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",
@@ -592,11 +702,107 @@ var OnesAdapter = class extends BaseAdapter {
 		}
 		return response.json();
 	}
+	async searchTaskByNumber(taskNumber) {
+		const session = await this.login();
+		const url = `${this.config.apiBase}/project/api/project/team/${session.teamUuid}/search?q=${encodeURIComponent(String(taskNumber))}&start=0&limit=10&types=task`;
+		const response = await fetch(url, { headers: { Authorization: `Bearer ${session.accessToken}` } });
+		if (!response.ok) return null;
+		const found = ((await response.json()).datas?.task ?? []).map((item) => item.fields).find((fields) => fields?.uuid && fields.number === taskNumber);
+		if (!found?.uuid) return null;
+		return {
+			key: `task-${found.uuid}`,
+			uuid: found.uuid,
+			number: found.number ?? taskNumber,
+			name: found.summary ?? "",
+			status: {
+				uuid: "",
+				name: "",
+				category: void 0
+			},
+			issueType: found.issue_type_uuid || found.issue_type_name ? {
+				uuid: found.issue_type_uuid ?? "",
+				name: found.issue_type_name ?? ""
+			} : void 0,
+			project: found.project_uuid || found.project_name ? {
+				uuid: found.project_uuid ?? "",
+				name: found.project_name ?? ""
+			} : void 0
+		};
+	}
 	async fetchIssueTypes() {
 		if (this.issueTypesCache) return this.issueTypesCache;
 		this.issueTypesCache = (await this.graphql(ISSUE_TYPES_QUERY, { orderBy: { namePinyin: "ASC" } }, "issueTypes")).data?.issueTypes ?? [];
 		return this.issueTypesCache;
 	}
+	async fetchProjects() {
+		return (await this.graphql(PROJECTS_QUERY, {
+			projectOrderBy: {
+				isPin: "DESC",
+				namePinyin: "ASC",
+				createTime: "DESC"
+			},
+			projectFilterGroup: [{
+				visibleInProject_equal: true,
+				isArchive_equal: false
+			}],
+			groupBy: { projects: {} },
+			orderBy: null,
+			pagination: {
+				limit: 50,
+				after: "",
+				preciseCount: true
+			}
+		}, "projects-group-list-for-project-view")).data?.buckets?.flatMap((bucket) => bucket.projects ?? []) ?? [];
+	}
+	async findTaskByNumber(taskNumber, projectUuid) {
+		const filter = { number_in: [taskNumber] };
+		if (projectUuid) filter.project_in = [projectUuid];
+		const found = ((await this.graphql(TASK_BY_NUMBER_QUERY, {
+			groupBy: { tasks: {} },
+			groupOrderBy: null,
+			orderBy: { createTime: "DESC" },
+			filterGroup: [filter],
+			search: null,
+			pagination: {
+				limit: 10,
+				preciseCount: false
+			},
+			limit: 10
+		}, "group-task-data")).data?.buckets?.flatMap((b) => b.tasks ?? []) ?? []).find((task) => task.number === taskNumber && (!projectUuid || task.project?.uuid === projectUuid));
+		if (found) return found;
+		if (projectUuid) return null;
+		return this.searchTaskByNumber(taskNumber);
+	}
+	async resolveTaskRef(input) {
+		const taskId = input.trim();
+		if (!taskId) throw new Error("ONES: taskId is required");
+		const numMatch = taskId.match(/^#?(\d+)$/);
+		if (numMatch) {
+			const taskNumber = Number.parseInt(numMatch[1], 10);
+			const found = await this.findTaskByNumber(taskNumber);
+			if (!found) throw new Error(`ONES: Task #${taskNumber} not found in current team`);
+			return {
+				key: found.key ?? `task-${found.uuid}`,
+				uuid: found.uuid
+			};
+		}
+		const displayId = parseDisplayId(taskId);
+		if (displayId) {
+			const project = (await this.fetchProjects()).find((item) => item.identifier?.toLowerCase() === displayId.identifier.toLowerCase());
+			if (!project) throw new Error(`ONES: Project identifier "${displayId.identifier}" not found in current team`);
+			const found = await this.findTaskByNumber(displayId.number, project.uuid);
+			if (!found) throw new Error(`ONES: Task "${taskId}" not found in current team`);
+			return {
+				key: found.key ?? `task-${found.uuid}`,
+				uuid: found.uuid
+			};
+		}
+		const key = taskId.startsWith("task-") ? taskId : `task-${taskId}`;
+		return {
+			key,
+			uuid: key.slice(5)
+		};
+	}
 	async searchTeamUsers(keyword) {
 		const session = await this.login();
 		const url = `${this.config.apiBase}/project/api/project/team/${session.teamUuid}/users/search`;
@@ -705,22 +911,25 @@ var OnesAdapter = class extends BaseAdapter {
 	* Fetch wiki page content via REST API.
 	* Endpoint: /wiki/api/wiki/team/{teamUuid}/online_page/{wikiUuid}/content
 	*/
-	async fetchWikiPageDetail(wikiUuid) {
+	async fetchWikiPageDetail(wikiUuid, teamUuid) {
 		const session = await this.login();
-		const url = `${this.config.apiBase}/wiki/api/wiki/team/${session.teamUuid}/page/${wikiUuid}/detail`;
+		const wikiTeamUuid = teamUuid ?? session.teamUuid;
+		const url = `${this.config.apiBase}/wiki/api/wiki/team/${wikiTeamUuid}/page/${wikiUuid}/detail`;
 		const response = await fetch(url, { headers: { Authorization: `Bearer ${session.accessToken}` } });
 		if (!response.ok) return {};
 		return response.json();
 	}
-	buildWikiImageUrl(session, refUuid, source, token) {
+	buildWikiImageUrl(session, refUuid, source, token, teamUuid) {
 		const encodedRefUuid = encodeURIComponent(refUuid);
 		const encodedSource = source.split("/").map((part) => encodeURIComponent(part)).join("/");
 		const encodedToken = encodeURIComponent(token);
-		return `${this.config.apiBase}/wiki/api/wiki/editor/${session.teamUuid}/${encodedRefUuid}/resources/${encodedSource}?token=${encodedToken}`;
+		const wikiTeamUuid = teamUuid ?? session.teamUuid;
+		return `${this.config.apiBase}/wiki/api/wiki/editor/${wikiTeamUuid}/${encodedRefUuid}/resources/${encodedSource}?token=${encodedToken}`;
 	}
-	async fetchWikiContent(wikiUuid) {
+	async fetchWikiContent(wikiUuid, teamUuid) {
 		const session = await this.login();
-		const url = `${this.config.apiBase}/wiki/api/wiki/team/${session.teamUuid}/online_page/${wikiUuid}/content`;
+		const wikiTeamUuid = teamUuid ?? session.teamUuid;
+		const url = `${this.config.apiBase}/wiki/api/wiki/team/${wikiTeamUuid}/online_page/${wikiUuid}/content`;
 		const response = await fetch(url, { headers: { Authorization: `Bearer ${session.accessToken}` } });
 		if (!response.ok) return {
 			content: "",
@@ -734,7 +943,7 @@ var OnesAdapter = class extends BaseAdapter {
 			content,
 			attachments: []
 		};
-		const detail = await this.fetchWikiPageDetail(wikiUuid);
+		const detail = await this.fetchWikiPageDetail(wikiUuid, wikiTeamUuid);
 		const refUuid = typeof detail.ref_uuid === "string" ? detail.ref_uuid : "";
 		if (!refUuid) return {
 			content,
@@ -745,38 +954,46 @@ var OnesAdapter = class extends BaseAdapter {
 			attachments: renderContext.imageSources.map((source, index) => ({
 				id: `${wikiUuid}-image-${index + 1}`,
 				name: attachmentNameFromPath(source),
-				url: this.buildWikiImageUrl(session, refUuid, source, token),
+				url: this.buildWikiImageUrl(session, refUuid, source, token, wikiTeamUuid),
 				mimeType: mimeTypeFromFileName(source),
 				size: 0
 			}))
 		};
 	}
 	/**
-	* Fetch a single task by UUID or number (e.g. "#95945" or "95945").
+	* Fetch a single task by UUID or number (e.g. "#1001" or "1001").
 	* 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 wikiRoute = parseOnesWikiPageRoute(params.id);
+		if (wikiRoute) {
+			const rendered = await this.fetchWikiContent(wikiRoute.wikiUuid, wikiRoute.teamUuid);
+			return {
+				id: wikiRoute.wikiUuid,
+				source: "ones",
+				title: `Wiki ${wikiRoute.wikiUuid}`,
+				description: rendered.content,
+				status: "open",
+				priority: "medium",
+				type: "feature",
+				labels: [],
+				reporter: "",
+				assignee: null,
+				createdAt: "",
+				updatedAt: "",
+				dueDate: null,
+				attachments: rendered.attachments,
+				raw: {
+					input: params.id,
+					teamUuid: wikiRoute.teamUuid,
+					wikiUuid: wikiRoute.wikiUuid
+				}
+			};
 		}
-		const task = (await this.graphql(TASK_DETAIL_QUERY, { key: `task-${taskUuid}` }, "Task")).data?.task;
-		if (!task) throw new Error(`ONES: Task "${taskUuid}" not found`);
+		if (isOnesWikiUrlInput(params.id)) throw new Error("ONES: Unsupported wiki page URL. Expected /wiki/#/team/{teamUuid}/space/{spaceUuid}/page/{wikiUuid}");
+		const taskRef = await this.resolveTaskRef(params.id);
+		const task = (await this.graphql(TASK_DETAIL_QUERY, { key: taskRef.key }, "Task")).data?.task;
+		if (!task) throw new Error(`ONES: Task "${params.id}" not found`);
 		const wikiRefs = /* @__PURE__ */ new Map();
 		for (const wiki of task.relatedWikiPages ?? []) if (!wiki.errorMessage) wikiRefs.set(wiki.uuid, {
 			title: wiki.title,
@@ -911,6 +1128,69 @@ var OnesAdapter = class extends BaseAdapter {
 			pageSize
 		};
 	}
+	async addManhour(params) {
+		const description = params.description.trim();
+		if (!description) throw new Error("ONES: description is required");
+		const taskRef = await this.resolveTaskRef(params.taskId);
+		const onesHours = toOnesHours(params.hours);
+		const workDate = parseManhourDate(params.date);
+		const key = (await this.graphql(ADD_MANHOUR_MUTATION, {
+			mode: "simple",
+			type: "recorded",
+			customData: {},
+			owner: (await this.login()).userUuid,
+			task: taskRef.uuid,
+			start_time: workDate.startTime,
+			hours: onesHours,
+			description
+		}, "add-manhour")).data?.addManhour?.key;
+		if (!key) throw new Error("ONES: Failed to add manhour");
+		return {
+			key,
+			taskUuid: taskRef.uuid,
+			hours: params.hours,
+			description,
+			date: workDate.date
+		};
+	}
+	async updateTaskPlanDates(params) {
+		const planStartDate = params.planStartDate?.trim();
+		const planEndDate = params.planEndDate?.trim();
+		if (!planStartDate && !planEndDate) throw new Error("ONES: planStartDate or planEndDate is required");
+		if (planStartDate && !isValidOnesDate(planStartDate)) throw new Error("ONES: planStartDate must be a valid YYYY-MM-DD date");
+		if (planEndDate && !isValidOnesDate(planEndDate)) throw new Error("ONES: planEndDate must be a valid YYYY-MM-DD date");
+		const taskRef = await this.resolveTaskRef(params.taskId);
+		const session = await this.login();
+		const fieldValues = [];
+		if (planStartDate) fieldValues.push({
+			field_uuid: "field027",
+			value: planStartDate
+		});
+		if (planEndDate) fieldValues.push({
+			field_uuid: "field028",
+			value: planEndDate
+		});
+		const response = await fetch(`${this.config.apiBase}/project/api/project/team/${session.teamUuid}/tasks/update3`, {
+			method: "POST",
+			headers: {
+				"Authorization": `Bearer ${session.accessToken}`,
+				"Content-Type": "application/json"
+			},
+			body: JSON.stringify({ tasks: [{
+				uuid: taskRef.uuid,
+				field_values: fieldValues
+			}] })
+		});
+		if (!response.ok) {
+			const text = await response.text().catch(() => "");
+			throw new Error(`ONES: Failed to update task plan dates: ${response.status} ${text}`);
+		}
+		return {
+			taskUuid: taskRef.uuid,
+			planStartDate: planStartDate ?? null,
+			planEndDate: planEndDate ?? null
+		};
+	}
 	async getRelatedIssues(params) {
 		const session = await this.login();
 		const taskKey = params.taskId.startsWith("task-") ? params.taskId : `task-${params.taskId}`;
@@ -1258,10 +1538,46 @@ function loadConfig(startDir) {
 	};
 }
 
+//#endregion
+//#region src/tools/add-manhour.ts
+const AddManhourSchema = z.object({
+	taskId: z.string().min(1).describe("The task or requirement ID, key, number, or displayId (e.g. \"task-mock-uuid\", \"mock-uuid\", \"1001\", or \"DEMO-1001\")"),
+	hours: z.number().positive().describe("Work hours to record. Natural hours are converted to ONES internal units."),
+	description: z.string().min(1).describe("Work log description."),
+	date: z.string().optional().describe("Optional work date. Accepts YYYY-MM-DD, a day number like \"11\", or a day-of-month phrase like \"11号\"; day-only values use the current year and month."),
+	source: z.string().optional().describe("Source to update. If omitted, uses the default source.")
+});
+async function handleAddManhour(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: formatAddManhourResult(await adapter.addManhour({
+			taskId: input.taskId,
+			hours: input.hours,
+			description: input.description,
+			date: input.date
+		}))
+	}] };
+}
+function formatAddManhourResult(result) {
+	return [
+		"Added manhour.",
+		"",
+		`- **Key**: ${result.key}`,
+		`- **Task UUID**: ${result.taskUuid}`,
+		`- **Hours**: ${result.hours}`,
+		`- **Date**: ${result.date ?? "today"}`,
+		`- **Description**: ${result.description}`
+	].join("\n");
+}
+
 //#endregion
 //#region src/tools/get-issue-detail.ts
 const GetIssueDetailSchema = z.object({
-	issueId: z.string().describe("The issue task ID or key (e.g. \"6W9vW3y8J9DO66Pu\" or \"task-6W9vW3y8J9DO66Pu\")"),
+	issueId: z.string().describe("The issue task ID or key (e.g. \"mock-issue-uuid\" or \"task-mock-issue-uuid\")"),
 	source: z.string().optional().describe("Source to fetch from. If omitted, uses the default source.")
 });
 /**
@@ -1336,7 +1652,7 @@ function formatIssueDetail(detail) {
 //#endregion
 //#region src/tools/get-related-issues.ts
 const GetRelatedIssuesSchema = z.object({
-	taskId: z.string().describe("The parent task ID or key (e.g. \"HRL2p8rTX4mQ9xMv\" or \"task-HRL2p8rTX4mQ9xMv\")"),
+	taskId: z.string().describe("The parent task ID or key (e.g. \"mock-task-uuid\" or \"task-mock-task-uuid\")"),
 	source: z.string().optional().describe("Source to fetch from. If omitted, uses the default source.")
 });
 async function handleGetRelatedIssues(input, adapters, defaultSource) {
@@ -1377,7 +1693,7 @@ function formatRelatedIssues(issues) {
 //#endregion
 //#region src/tools/get-requirement.ts
 const GetRequirementSchema = z.object({
-	id: z.string().describe("The requirement/issue ID"),
+	id: z.string().describe("The requirement/issue ID, task number, or ONES wiki page URL"),
 	source: z.string().optional().describe("Source to fetch from. If omitted, uses the default source.")
 });
 async function downloadImageAsBase64(url, fallbackMimeType = "image/png") {
@@ -1572,6 +1888,40 @@ async function handleSearchRequirements(input, adapters, defaultSource) {
 	}] };
 }
 
+//#endregion
+//#region src/tools/update-task-plan-dates.ts
+const DateSchema = z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Expected YYYY-MM-DD");
+const UpdateTaskPlanDatesSchema = z.object({
+	taskId: z.string().min(1).describe("The task or requirement ID, key, number, or displayId (e.g. \"task-mock-uuid\", \"mock-uuid\", \"1001\", or \"DEMO-1001\")"),
+	planStartDate: DateSchema.optional().describe("Plan start date in YYYY-MM-DD format."),
+	planEndDate: DateSchema.optional().describe("Plan end date in YYYY-MM-DD format."),
+	source: z.string().optional().describe("Source to update. If omitted, uses the default source.")
+});
+async function handleUpdateTaskPlanDates(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: formatUpdateTaskPlanDatesResult(await adapter.updateTaskPlanDates({
+			taskId: input.taskId,
+			planStartDate: input.planStartDate,
+			planEndDate: input.planEndDate
+		}))
+	}] };
+}
+function formatUpdateTaskPlanDatesResult(result) {
+	const lines = [
+		"Updated task plan dates.",
+		"",
+		`- **Task UUID**: ${result.taskUuid}`
+	];
+	if (result.planStartDate) lines.push(`- **Plan Start Date**: ${result.planStartDate}`);
+	if (result.planEndDate) lines.push(`- **Plan End Date**: ${result.planEndDate}`);
+	return lines.join("\n");
+}
+
 //#endregion
 //#region src/index.ts
 /**
@@ -1697,6 +2047,32 @@ async function main() {
 			};
 		}
 	});
+	server.tool("add_manhour", "Add a work-hour record to a ONES task, bug, or requirement. Supports task key, uuid, number, or displayId.", AddManhourSchema.shape, async (params) => {
+		try {
+			return await handleAddManhour(params, adapters, config.config.defaultSource);
+		} catch (err) {
+			return {
+				content: [{
+					type: "text",
+					text: `Error: ${err.message}`
+				}],
+				isError: true
+			};
+		}
+	});
+	server.tool("update_task_plan_dates", "Update plan start and/or plan end dates for a ONES task, bug, or requirement. Supports task key, uuid, number, or displayId.", UpdateTaskPlanDatesSchema.shape, async (params) => {
+		try {
+			return await handleUpdateTaskPlanDates(params, adapters, config.config.defaultSource);
+		} catch (err) {
+			return {
+				content: [{
+					type: "text",
+					text: `Error: ${err.message}`
+				}],
+				isError: true
+			};
+		}
+	});
 	const transport = new StdioServerTransport();
 	await server.connect(transport);
 }