@gaodes/pi-gitlab 0.3.0

package/src/tools/gitlab_mr_create.ts

@@ -0,0 +1,83 @@
+import type {
+	ExtensionAPI,
+	ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { requireSetup, setupRequiredResult } from "../lib/errors.js";
+import { glab } from "../lib/glab.js";
+import { requireConfirm } from "../lib/confirm.js";
+import { resolveProject } from "../lib/projectFallback.js";
+import { resolveProjectId } from "../lib/resolveProjectId.js";
+import { OptionalProject } from "../lib/schemas.js";
+
+export function registerGitlabMrCreate(pi: ExtensionAPI) {
+	pi.registerTool({
+		name: "gitlab_mr_create",
+		label: "Create Merge Request",
+		description: "Create a new merge request. Requires confirmation.",
+		parameters: Type.Object(
+			{
+				project: OptionalProject,
+				sourceBranch: Type.String({ description: "Source branch name" }),
+				targetBranch: Type.String({ description: "Target branch name" }),
+				title: Type.String({ description: "MR title" }),
+				description: Type.Optional(
+					Type.String({ description: "MR description (markdown supported)" }),
+				),
+				draft: Type.Optional(Type.Boolean({ default: false })),
+				confirm: Type.Optional(Type.Boolean({ default: false })),
+				dryRun: Type.Optional(Type.Boolean({ default: false })),
+			},
+			{ additionalProperties: false },
+		),
+		async execute(
+			_toolCallId,
+			params,
+			_signal,
+			_onUpdate,
+			ctx: ExtensionContext,
+		) {
+			try {
+				requireSetup(ctx.cwd);
+			} catch {
+				return setupRequiredResult();
+			}
+
+			const projectPath = await resolveProject(params.project, ctx.cwd);
+			const projectId = await resolveProjectId(projectPath);
+
+			const preview = `Create MR **${params.title}**\n${params.sourceBranch} → ${params.targetBranch}\nProject: \`${projectPath}\``;
+			const blocked = requireConfirm(preview, {
+				confirm: params.confirm,
+				dryRun: params.dryRun,
+			});
+			if (blocked) return blocked;
+
+			const body: Record<string, unknown> = {
+				source_branch: params.sourceBranch,
+				target_branch: params.targetBranch,
+				title: params.draft ? `Draft: ${params.title}` : params.title,
+			};
+			if (params.description) body.description = params.description;
+
+			const result = await glab([
+				"api",
+				"-X",
+				"POST",
+				`projects/${projectId}/merge_requests`,
+				...Object.entries(body).flatMap(([k, v]) => ["-f", `${k}=${v}`]),
+			]);
+
+			const mr = result as Record<string, unknown>;
+			return {
+				content: [
+					{
+						type: "text",
+						text: `✅ MR created: !${mr.iid} — ${mr.title}\n${mr.web_url ?? ""}`,
+					},
+				],
+				details: { success: true, mr },
+			};
+		},
+	});
+}

package/src/tools/gitlab_mr_list.ts

@@ -0,0 +1,108 @@
+import type {
+	ExtensionAPI,
+	ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { requireSetup, setupRequiredResult } from "../lib/errors.js";
+import { glab } from "../lib/glab.js";
+import { limitRows } from "../lib/pagination.js";
+import { resolveProject } from "../lib/projectFallback.js";
+import { resolveProjectId } from "../lib/resolveProjectId.js";
+import { MaxRows, OptionalProject } from "../lib/schemas.js";
+
+interface MR {
+	iid: number;
+	title: string;
+	author?: { name?: string };
+	state: string;
+	pipeline?: { status?: string };
+	target_branch?: string;
+}
+
+export function registerGitlabMrList(pi: ExtensionAPI) {
+	pi.registerTool({
+		name: "gitlab_mr_list",
+		label: "List Merge Requests",
+		description:
+			"List merge requests with optional filters and transparent pagination.",
+		parameters: Type.Object(
+			{
+				project: OptionalProject,
+				state: Type.Optional(
+					Type.Union(
+						[
+							Type.Literal("opened"),
+							Type.Literal("closed"),
+							Type.Literal("merged"),
+							Type.Literal("all"),
+						],
+						{ default: "opened" },
+					),
+				),
+				author: Type.Optional(Type.String()),
+				assignee: Type.Optional(Type.String()),
+				reviewer: Type.Optional(Type.String()),
+				labels: Type.Optional(Type.Array(Type.String())),
+				targetBranch: Type.Optional(Type.String()),
+				sourceBranch: Type.Optional(Type.String()),
+				maxRows: MaxRows,
+			},
+			{ additionalProperties: false },
+		),
+		async execute(
+			_toolCallId,
+			params,
+			_signal,
+			_onUpdate,
+			ctx: ExtensionContext,
+		) {
+			try {
+					requireSetup(ctx.cwd);
+				} catch {
+					return setupRequiredResult();
+				}
+
+				const projectPath = await resolveProject(params.project, ctx.cwd);
+			const projectId = await resolveProjectId(projectPath);
+
+			const query = new URLSearchParams();
+			query.set("state", params.state ?? "opened");
+			if (params.author) query.set("author_username", params.author);
+			if (params.assignee) query.set("assignee_username", params.assignee);
+			if (params.reviewer) query.set("reviewer_username", params.reviewer);
+			if (params.labels?.length) query.set("labels", params.labels.join(","));
+			if (params.targetBranch) query.set("target_branch", params.targetBranch);
+			if (params.sourceBranch) query.set("source_branch", params.sourceBranch);
+			query.set("per_page", "100");
+
+			const mrs = (await glab([
+				"api",
+				"--paginate",
+				`projects/${projectId}/merge_requests?${query.toString()}`,
+			])) as MR[];
+
+			const limited = limitRows(mrs, params.maxRows ?? 25);
+			if (limited.length === 0) {
+				return {
+					content: [{ type: "text", text: "No merge requests found." }],
+					details: { success: true, count: 0, mrs: [] },
+				};
+			}
+
+			const lines = [
+				"| IID | Title | Author | State | Pipeline | Target |",
+				"|---|---|---|---|---|---|",
+			];
+			for (const mr of limited) {
+				lines.push(
+					`| ${mr.iid} | ${mr.title} | ${mr.author?.name ?? "-"} | ${mr.state} | ${mr.pipeline?.status ?? "-"} | ${mr.target_branch ?? "-"} |`,
+				);
+			}
+
+			return {
+				content: [{ type: "text", text: lines.join("\n") }],
+				details: { success: true, count: limited.length, mrs: limited },
+			};
+		},
+	});
+}

package/src/tools/gitlab_mr_merge.ts

@@ -0,0 +1,86 @@
+import type {
+	ExtensionAPI,
+	ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { requireSetup, setupRequiredResult } from "../lib/errors.js";
+import { glab } from "../lib/glab.js";
+import { requireConfirm } from "../lib/confirm.js";
+import { resolveProject } from "../lib/projectFallback.js";
+import { resolveProjectId } from "../lib/resolveProjectId.js";
+import { OptionalProject } from "../lib/schemas.js";
+
+export function registerGitlabMrMerge(pi: ExtensionAPI) {
+	pi.registerTool({
+		name: "gitlab_mr_merge",
+		label: "Merge Merge Request",
+		description: "Merge an open merge request. Requires confirmation.",
+		parameters: Type.Object(
+			{
+				project: OptionalProject,
+				mrId: Type.Number({ description: "MR IID" }),
+				squash: Type.Optional(Type.Boolean({ default: false })),
+				removeSourceBranch: Type.Optional(
+					Type.Boolean({ default: false }),
+				),
+				confirm: Type.Optional(Type.Boolean({ default: false })),
+				dryRun: Type.Optional(Type.Boolean({ default: false })),
+			},
+			{ additionalProperties: false },
+		),
+		async execute(
+			_toolCallId,
+			params,
+			_signal,
+			_onUpdate,
+			ctx: ExtensionContext,
+		) {
+			try {
+				requireSetup(ctx.cwd);
+			} catch {
+				return setupRequiredResult();
+			}
+
+			const projectPath = await resolveProject(params.project, ctx.cwd);
+			const projectId = await resolveProjectId(projectPath);
+
+			// Fetch MR details for the preview
+			const mr = (await glab([
+				"api",
+				`projects/${projectId}/merge_requests/${params.mrId}`,
+			])) as Record<string, unknown>;
+
+			const preview = `Merge MR !${params.mrId}: **${mr.title}**\n${mr.source_branch} → ${mr.target_branch}\nProject: \`${projectPath}\`${params.squash ? "\n(squash)" : ""}${params.removeSourceBranch ? "\n(remove source branch)" : ""}`;
+			const blocked = requireConfirm(preview, {
+				confirm: params.confirm,
+				dryRun: params.dryRun,
+			});
+			if (blocked) return blocked;
+
+			const body: Record<string, unknown> = {};
+			if (params.squash !== undefined) body.squash = params.squash;
+			if (params.removeSourceBranch !== undefined)
+				body.should_remove_source_branch = params.removeSourceBranch;
+
+			const result = await glab([
+				"api",
+				"-X",
+				"PUT",
+				`projects/${projectId}/merge_requests/${params.mrId}/merge`,
+				...(Object.keys(body).length > 0
+					? Object.entries(body).flatMap(([k, v]) => ["-f", `${k}=${v}`])
+					: []),
+			]);
+
+			return {
+				content: [
+					{
+						type: "text",
+						text: `✅ MR !${params.mrId} merged\n${(result as Record<string, unknown>).web_url ?? ""}`,
+					},
+				],
+				details: { success: true, mr: result },
+			};
+		},
+	});
+}

package/src/tools/gitlab_mr_view.ts

@@ -0,0 +1,99 @@
+import type {
+	ExtensionAPI,
+	ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { requireSetup, setupRequiredResult } from "../lib/errors.js";
+import { glab } from "../lib/glab.js";
+import { resolveProject } from "../lib/projectFallback.js";
+import { resolveProjectId } from "../lib/resolveProjectId.js";
+import { OptionalProject } from "../lib/schemas.js";
+
+export function registerGitlabMrView(pi: ExtensionAPI) {
+	pi.registerTool({
+		name: "gitlab_mr_view",
+		label: "View Merge Request",
+		description:
+			"View a merge request with metadata, pipeline status, discussions, and optional diff.",
+		parameters: Type.Object(
+			{
+				project: OptionalProject,
+				mrId: Type.Number({ description: "MR IID (project-relative number)." }),
+				includeDiff: Type.Optional(Type.Boolean({ default: false })),
+				includeDiscussions: Type.Optional(Type.Boolean({ default: true })),
+			},
+			{ additionalProperties: false },
+		),
+		async execute(
+			_toolCallId,
+			params,
+			_signal,
+			_onUpdate,
+			ctx: ExtensionContext,
+		) {
+			try {
+					requireSetup(ctx.cwd);
+				} catch {
+					return setupRequiredResult();
+				}
+
+				const projectPath = await resolveProject(params.project, ctx.cwd);
+			const projectId = await resolveProjectId(projectPath);
+
+			const mr = (await glab([
+				"api",
+				`projects/${projectId}/merge_requests/${params.mrId}`,
+			])) as Record<string, unknown>;
+
+			const parts: string[] = [];
+			parts.push(`## MR !${params.mrId}: ${String(mr.title ?? "")}`);
+			parts.push(`State: ${String(mr.state ?? "unknown")}`);
+			parts.push(`Author: ${(mr.author as { name?: string })?.name ?? "-"}`);
+			parts.push(
+				`Source → Target: ${String(mr.source_branch ?? "?")} → ${String(mr.target_branch ?? "?")}`,
+			);
+			parts.push(`URL: ${String(mr.web_url ?? "-")}`);
+
+			if (params.includeDiscussions) {
+				try {
+					const discussions = (await glab([
+						"api",
+						`projects/${projectId}/merge_requests/${params.mrId}/discussions`,
+					])) as Array<Record<string, unknown>>;
+					parts.push(`\nDiscussions: ${discussions.length}`);
+				} catch {
+					parts.push("\nDiscussions: unavailable");
+				}
+			}
+
+			if (params.includeDiff) {
+				try {
+					const diff = (await glab([
+						"api",
+						`projects/${projectId}/merge_requests/${params.mrId}/changes`,
+					])) as {
+						changes?: Array<{
+							old_path: string;
+							new_path: string;
+							diff: string;
+						}>;
+					};
+					parts.push("\n### Diff");
+					for (const c of diff.changes ?? []) {
+						parts.push(`\n**${c.old_path}**`);
+						parts.push("```diff");
+						parts.push(c.diff.slice(0, 2000));
+						parts.push("```");
+					}
+				} catch {
+					parts.push("\nDiff: unavailable");
+				}
+			}
+
+			return {
+				content: [{ type: "text", text: parts.join("\n") }],
+				details: { success: true, mr },
+			};
+		},
+	});
+}

package/src/tools/gitlab_pipeline_run.ts

@@ -0,0 +1,68 @@
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { requireSetup, setupRequiredResult } from "../lib/errors.js";
+import { glab } from "../lib/glab.js";
+import { requireConfirm } from "../lib/confirm.js";
+import { resolveProject } from "../lib/projectFallback.js";
+import { resolveProjectId } from "../lib/resolveProjectId.js";
+import { OptionalProject } from "../lib/schemas.js";
+
+export function registerGitlabPipelineRun(pi: ExtensionAPI) {
+	pi.registerTool({
+		name: "gitlab_pipeline_run",
+		label: "Run Pipeline",
+		description: "Trigger a new pipeline for a branch. Requires confirmation.",
+		parameters: Type.Object(
+			{
+				project: OptionalProject,
+				ref: Type.String({ description: "Branch or tag to run pipeline for" }),
+				variables: Type.Optional(Type.Object({}, { additionalProperties: true })),
+				confirm: Type.Optional(Type.Boolean({ default: false })),
+				dryRun: Type.Optional(Type.Boolean({ default: false })),
+			},
+			{ additionalProperties: false },
+		),
+		async execute(_toolCallId, params, _signal, _onUpdate, ctx: ExtensionContext) {
+			try {
+				requireSetup(ctx.cwd);
+			} catch {
+				return setupRequiredResult();
+			}
+
+			const cwd = ctx.cwd;
+			const projectPath = await resolveProject(params.project, cwd);
+			const projectId = await resolveProjectId(projectPath);
+
+			const preview = `Trigger pipeline for \`${params.ref}\`\nProject: \`${projectPath}\``;
+			const blocked = requireConfirm(preview, { confirm: params.confirm, dryRun: params.dryRun });
+			if (blocked) return blocked;
+
+			const body: Record<string, unknown> = { ref: params.ref };
+			if (params.variables && Object.keys(params.variables).length > 0) {
+				body.variables = Object.entries(params.variables).map(([key, value]) => ({
+					key,
+					value: String(value),
+				}));
+			}
+
+			const result = await glab([
+				"api",
+				"-X",
+				"POST",
+				`projects/${projectId}/pipeline`,
+				...Object.entries(body).flatMap(([k, v]) => ["-f", `${k}=${typeof v === "string" ? v : JSON.stringify(v)}`]),
+			]);
+
+			const pipeline = result as Record<string, unknown>;
+			return {
+				content: [
+					{
+						type: "text",
+						text: `✅ Pipeline triggered: #${pipeline.id}\nStatus: ${pipeline.status}\n${pipeline.web_url ?? ""}`,
+					},
+				],
+				details: { success: true, pipeline },
+			};
+		},
+	});
+}

package/src/tools/gitlab_pipeline_status.ts

@@ -0,0 +1,122 @@
+import type {
+	ExtensionAPI,
+	ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { requireSetup, setupRequiredResult } from "../lib/errors.js";
+import { glab } from "../lib/glab.js";
+import { resolveProject } from "../lib/projectFallback.js";
+import { resolveProjectId } from "../lib/resolveProjectId.js";
+import { OptionalProject } from "../lib/schemas.js";
+
+interface Pipeline {
+	id: number;
+	status: string;
+	ref: string;
+	sha: string;
+	web_url?: string;
+}
+
+interface Job {
+	id: number;
+	name: string;
+	status: string;
+	stage: string;
+}
+
+export function registerGitlabPipelineStatus(pi: ExtensionAPI) {
+	pi.registerTool({
+		name: "gitlab_pipeline_status",
+		label: "Pipeline Status",
+		description:
+			"Check pipeline status for a branch, commit SHA, or pipeline ID.",
+		parameters: Type.Object(
+			{
+				project: OptionalProject,
+				ref: Type.Optional(
+					Type.String({ description: "Branch name or commit SHA." }),
+				),
+				pipelineId: Type.Optional(Type.Number()),
+				includeJobs: Type.Optional(Type.Boolean({ default: false })),
+			},
+			{ additionalProperties: false },
+		),
+		async execute(
+			_toolCallId,
+			params,
+			_signal,
+			_onUpdate,
+			ctx: ExtensionContext,
+		) {
+			try {
+					requireSetup(ctx.cwd);
+				} catch {
+					return setupRequiredResult();
+				}
+
+				const projectPath = await resolveProject(params.project, ctx.cwd);
+			const projectId = await resolveProjectId(projectPath);
+
+			let pipeline: Pipeline;
+
+			if (params.pipelineId) {
+				pipeline = (await glab([
+					"api",
+					`projects/${projectId}/pipelines/${params.pipelineId}`,
+				])) as Pipeline;
+			} else if (params.ref) {
+				const pipelines = (await glab([
+					"api",
+					`projects/${projectId}/pipelines?ref=${encodeURIComponent(params.ref)}&per_page=1`,
+				])) as Pipeline[];
+				if (!pipelines.length) {
+					return {
+						content: [
+							{
+								type: "text",
+								text: `No pipeline found for ref \`${params.ref}\`.`,
+							},
+						],
+						details: { success: true, found: false },
+					};
+				}
+				pipeline = pipelines[0];
+			} else {
+				const pipelines = (await glab([
+					"api",
+					`projects/${projectId}/pipelines?per_page=1`,
+				])) as Pipeline[];
+				if (!pipelines.length) {
+					return {
+						content: [{ type: "text", text: "No recent pipelines found." }],
+						details: { success: true, found: false },
+					};
+				}
+				pipeline = pipelines[0];
+			}
+
+			const parts = [
+				`Pipeline **#${pipeline.id}** — ${pipeline.status}`,
+				`Ref: \`${pipeline.ref}\``,
+				`SHA: \`${pipeline.sha}\``,
+				`URL: ${pipeline.web_url ?? "-"}`,
+			];
+
+			if (params.includeJobs) {
+				const jobs = (await glab([
+					"api",
+					`projects/${projectId}/pipelines/${pipeline.id}/jobs?per_page=100`,
+				])) as Job[];
+				parts.push("\n| Job | Stage | Status |", "|---|---|---|");
+				for (const job of jobs) {
+					parts.push(`| ${job.name} | ${job.stage} | ${job.status} |`);
+				}
+			}
+
+			return {
+				content: [{ type: "text", text: parts.join("\n") }],
+				details: { success: true, pipeline, jobs: params.includeJobs },
+			};
+		},
+	});
+}

package/src/tools/gitlab_project_resolve.ts

@@ -0,0 +1,59 @@
+import type {
+	ExtensionAPI,
+	ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { requireSetup, setupRequiredResult } from "../lib/errors.js";
+import { resolveProject } from "../lib/projectFallback.js";
+import { resolveProjectId } from "../lib/resolveProjectId.js";
+
+export function registerGitlabProjectResolve(pi: ExtensionAPI) {
+	pi.registerTool({
+		name: "gitlab_project_resolve",
+		label: "Resolve GitLab Project",
+		description:
+			"Resolve a GitLab project path (namespace/path) to a numeric project ID. Searches with pagination, exact-matches path_with_namespace, verifies the ID, then caches.",
+		parameters: Type.Object(
+			{
+				project: Type.Optional(
+					Type.String({
+						description:
+							"Project path or numeric ID. Optional — falls back to CWD git remote, then settings default.",
+					}),
+				),
+				force: Type.Optional(
+					Type.Boolean({
+						default: false,
+						description: "Bypass cache and re-resolve.",
+					}),
+				),
+			},
+			{ additionalProperties: false },
+		),
+		async execute(
+			_toolCallId,
+			params,
+			_signal,
+			_onUpdate,
+			ctx: ExtensionContext,
+		) {
+			try {
+					requireSetup(ctx.cwd);
+				} catch {
+					return setupRequiredResult();
+				}
+
+				const project = await resolveProject(params.project, ctx.cwd);
+			const id = await resolveProjectId(project, params.force);
+			return {
+				content: [
+					{
+						type: "text",
+						text: `Project \`${project}\` → ID **${id}**`,
+					},
+				],
+				details: { success: true, project, id },
+			};
+		},
+	});
+}