@ai-projector/ide 0.0.0-stage → 0.11.1

package/packages/server/modules/gitlab/merge-requests.js

@@ -0,0 +1,287 @@
+import { HttpError } from "../http/index.js";
+import { gitlabReader } from "./api.js";
+import { DIFF_LIMIT, diffCounts, diffStatus, isBinaryDiff, nextPage, projectId, readGitlabFileAt, safePath, } from "./browser.js";
+import { pipeline } from "./pipelines.js";
+import { awardReactions, gitlabLabels, gitlabNotes, gitlabUser, optional, TRACKER_PAGE, trackerPage, } from "./trackers.js";
+/** GitHub states are the API contract; GitLab calls the open state `opened` and has `merged`. */
+const STATES = {
+    open: "opened",
+    closed: "closed",
+    merged: "merged",
+    all: "all",
+};
+const FILE_PAGE = 100;
+const DRAFT_TITLE = /^\s*(draft|wip)\s*:/i;
+const FILE_STATUS = {
+    A: "added",
+    D: "removed",
+    R: "renamed",
+    C: "copied",
+    T: "modified",
+    M: "modified",
+};
+function pullState(raw) {
+    if (raw.merged_at || raw.state === "merged")
+        return "merged";
+    if (raw.state === "closed")
+        return "closed";
+    return "open";
+}
+function pull(raw, reactions = []) {
+    const source = raw.head_pipeline ?? raw.pipeline;
+    return {
+        number: raw.iid,
+        title: raw.title || "",
+        state: pullState(raw),
+        draft: raw.draft === true || raw.work_in_progress === true || DRAFT_TITLE.test(raw.title || ""),
+        author: gitlabUser(raw.author),
+        labels: gitlabLabels(raw.labels),
+        head: raw.source_branch || "",
+        base: raw.target_branch || "",
+        body: raw.description || "",
+        reactions,
+        htmlUrl: raw.web_url || "",
+        createdAt: raw.created_at || "",
+        updatedAt: raw.updated_at || "",
+        ...(source ? { pipeline: pipeline(source) } : {}),
+        ...(typeof raw.user_notes_count === "number" ? { comments: raw.user_notes_count } : {}),
+        ...(raw.detailed_merge_status ? { mergeStatus: raw.detailed_merge_status } : {}),
+        ...(raw.has_conflicts === true ? { hasConflicts: true } : {}),
+        ...(raw.blocking_discussions_resolved === false ? { blockingDiscussionsResolved: false } : {}),
+    };
+}
+function mergeRequestFile(raw) {
+    const counts = raw.diff ? diffCounts(raw.diff) : { additions: 0, deletions: 0 };
+    const binary = isBinaryDiff(raw);
+    return {
+        path: raw.new_path,
+        previousPath: raw.old_path === raw.new_path ? "" : raw.old_path,
+        status: FILE_STATUS[diffStatus(raw)] ?? "modified",
+        additions: counts.additions,
+        deletions: counts.deletions,
+        ...(binary ? { binary: true } : {}),
+        ...(raw.too_large === true ? { tooLarge: true } : {}),
+        ...(raw.generated_file === true ? { generated: true } : {}),
+    };
+}
+/** `changes_count` is a string and turns into `1000+` when GitLab caps a huge merge request. */
+function changesCount(raw, loaded) {
+    const value = raw.changes_count;
+    if (value === undefined || value === "")
+        return { changedFiles: loaded, capped: false };
+    if (typeof value === "string" && value.endsWith("+")) {
+        const capped = Number(value.slice(0, -1));
+        return { changedFiles: Number.isFinite(capped) ? capped : loaded, capped: true };
+    }
+    const count = Number(value);
+    return Number.isFinite(count)
+        ? { changedFiles: count, capped: false }
+        : { changedFiles: loaded, capped: false };
+}
+/** `diff_refs` is empty right after the merge request is created and populates asynchronously. */
+function diffRefsOf(raw) {
+    const base = raw.diff_refs?.base_sha || "";
+    const head = raw.diff_refs?.head_sha || "";
+    if (!base || !head)
+        return undefined;
+    return { baseSha: base, startSha: raw.diff_refs?.start_sha || base, headSha: head };
+}
+function approvalsOf(raw) {
+    const approvedBy = (raw.approved_by ?? []).flatMap((entry) => entry.user ? [gitlabUser(entry.user)] : []);
+    const required = Number(raw.approvals_required);
+    const left = Number(raw.approvals_left);
+    return {
+        approvedBy,
+        required: Number.isFinite(required) && required > 0 ? required : 0,
+        left: Number.isFinite(left) && left >= 0 ? left : 0,
+    };
+}
+function approvedBy(raw) {
+    return (raw.approved_by ?? []).flatMap((entry) => entry.user
+        ? [
+            {
+                id: entry.user.id ?? 0,
+                author: gitlabUser(entry.user),
+                // Approvals are the only review state this endpoint exposes; resubmissions are not.
+                state: "approved",
+                body: "",
+                htmlUrl: "",
+                submittedAt: "",
+            },
+        ]
+        : []);
+}
+/** `/changes` is the pre-16 fallback of `/diffs`: one unpaginated array, still capped at the limit. */
+async function changesFallback(reader, id, iid) {
+    const data = await reader.get(`/projects/${id}/merge_requests/${iid}/changes`);
+    const rows = Array.isArray(data.changes) ? data.changes : [];
+    return { files: rows.slice(0, DIFF_LIMIT), truncated: rows.length > DIFF_LIMIT };
+}
+async function mergeRequestDiffs(reader, id, iid) {
+    const files = [];
+    for (let fetched = 0; fetched < DIFF_LIMIT / FILE_PAGE; fetched++) {
+        const page = fetched + 1;
+        let rows;
+        try {
+            const response = await reader.request(`/projects/${id}/merge_requests/${iid}/diffs?per_page=${FILE_PAGE}&page=${page}`);
+            rows = Array.isArray(response.data) ? response.data : [];
+            files.push(...rows);
+            const next = nextPage(response.headers, page, rows.length, FILE_PAGE);
+            if (!next)
+                return { files, truncated: files.length > DIFF_LIMIT };
+            if (fetched === DIFF_LIMIT / FILE_PAGE - 1)
+                return { files, truncated: true };
+        }
+        catch (error) {
+            // Instances older than 16.0 have no `/diffs`; the whole diff comes from `/changes`.
+            if (page === 1 && error instanceof HttpError && error.status === 404)
+                return await changesFallback(reader, id, iid);
+            throw error;
+        }
+    }
+    return { files, truncated: true };
+}
+/** Files of one merge request with the pinned SHAs; the detail and the changes panel share this read. */
+async function mergeRequestChanges(reader, id, iid, raw) {
+    const { files: diffs, truncated } = await mergeRequestDiffs(reader, id, iid);
+    const files = diffs.map(mergeRequestFile);
+    const { changedFiles, capped } = changesCount(raw, files.length);
+    const refs = diffRefsOf(raw);
+    return {
+        files,
+        changedFiles,
+        changedFilesCapped: capped,
+        filesTruncated: truncated || capped || changedFiles > files.length,
+        ...(refs ? { diffRefs: refs } : {}),
+    };
+}
+function mergeRequestNumber(number) {
+    if (!Number.isInteger(number) || number <= 0)
+        throw new HttpError(400, "Укажите номер merge request");
+    return number;
+}
+/** Lightweight changed-file list for the sidebar tree: no conversation and approvals. */
+export async function browseGitlabMergeRequestFiles(repository, number) {
+    const iid = mergeRequestNumber(number);
+    const reader = await gitlabReader(repository);
+    const id = projectId(reader.target.path);
+    const raw = await reader.get(`/projects/${id}/merge_requests/${iid}`);
+    return mergeRequestChanges(reader, id, iid, raw);
+}
+/** Both readable sides of one changed file, pinned by the merge request diff refs. */
+export async function browseGitlabMergeRequestDiff(repository, number, path) {
+    const iid = mergeRequestNumber(number);
+    safePath(path);
+    const reader = await gitlabReader(repository);
+    const id = projectId(reader.target.path);
+    const raw = await reader.get(`/projects/${id}/merge_requests/${iid}`);
+    const refs = diffRefsOf(raw);
+    if (!refs)
+        throw new HttpError(409, "GitLab ещё не подготовил diff merge request. Обновите карточку позже");
+    const { files: diffs } = await mergeRequestDiffs(reader, id, iid);
+    const file = diffs.find((item) => item.new_path === path || item.old_path === path);
+    if (!file)
+        throw new HttpError(404, "Файл не входит в этот merge request");
+    const headProject = raw.source_project_id ? String(raw.source_project_id) : id;
+    const base = { hash: refs.headSha, parent: refs.baseSha.slice(0, 7) };
+    if (file.too_large === true)
+        return { path, original: "", modified: "", ...base, binary: false, tooLarge: true };
+    if (isBinaryDiff(file))
+        return { path, original: "", modified: "", ...base, binary: true, tooLarge: false };
+    const read = async (project, ref, name) => {
+        try {
+            return await readGitlabFileAt(reader, project, ref, name);
+        }
+        catch (error) {
+            if (error instanceof HttpError && error.status === 413)
+                return undefined;
+            throw error;
+        }
+    };
+    const [originalSide, modifiedSide] = await Promise.all([
+        file.new_file ? { content: "", binary: false } : read(id, refs.baseSha, file.old_path),
+        file.deleted_file
+            ? { content: "", binary: false }
+            : read(headProject, refs.headSha, file.new_path),
+    ]);
+    if (!originalSide || !modifiedSide)
+        return { path, original: "", modified: "", ...base, binary: false, tooLarge: true };
+    if (originalSide.binary || modifiedSide.binary)
+        return { path, original: "", modified: "", ...base, binary: true, tooLarge: false };
+    return {
+        path,
+        original: originalSide.content,
+        modified: modifiedSide.content,
+        ...base,
+        binary: false,
+        tooLarge: false,
+    };
+}
+/** One page of the project merge requests, most recently updated first. */
+export async function browseGitlabMergeRequests(repository, params = {}) {
+    const state = STATES[params.state ?? ""] ?? "opened";
+    const page = trackerPage(params.page);
+    const reader = await gitlabReader(repository);
+    const query = new URLSearchParams({
+        state,
+        per_page: String(TRACKER_PAGE),
+        page: String(page),
+        order_by: "updated_at",
+        sort: "desc",
+        with_labels_details: "true",
+    });
+    const response = await reader.request(`/projects/${projectId(reader.target.path)}/merge_requests?${query}`);
+    const rows = Array.isArray(response.data) ? response.data : [];
+    // The list endpoint carries no award emoji: reactions stay empty instead of one request per MR.
+    return {
+        pulls: rows.map((row) => pull(row)),
+        next: nextPage(response.headers, page, rows.length, TRACKER_PAGE),
+    };
+}
+/** Merge request description, conversation, approvals and changed files, each read up to a bound. */
+export async function browseGitlabMergeRequest(repository, number) {
+    const iid = mergeRequestNumber(number);
+    const reader = await gitlabReader(repository);
+    const id = projectId(reader.target.path);
+    const [raw, awards, approvals] = await Promise.all([
+        reader.get(`/projects/${id}/merge_requests/${iid}`),
+        optional(reader.get(`/projects/${id}/merge_requests/${iid}/award_emoji`), []),
+        optional(reader.get(`/projects/${id}/merge_requests/${iid}/approvals`), {}),
+    ]);
+    const { comments, truncated } = await gitlabNotes(reader, `/projects/${id}/merge_requests/${iid}/notes`);
+    let commits = raw.commits_count ?? 0;
+    if (raw.commits_count === undefined) {
+        const response = await reader
+            .request(`/projects/${id}/merge_requests/${iid}/commits?per_page=1`)
+            .catch(() => null);
+        const total = Number(response?.headers.get("X-Total"));
+        if (Number.isFinite(total))
+            commits = total;
+    }
+    const changes = await mergeRequestChanges(reader, id, iid, raw);
+    return {
+        pull: pull(raw, awardReactions(awards)),
+        commits,
+        additions: changes.files.reduce((sum, file) => sum + file.additions, 0),
+        deletions: changes.files.reduce((sum, file) => sum + file.deletions, 0),
+        changedFiles: changes.changedFiles,
+        comments,
+        reviews: approvedBy(approvals),
+        reviewers: (raw.reviewers ?? []).map(gitlabUser),
+        approvals: approvalsOf(approvals),
+        pipeline: raw.head_pipeline
+            ? pipeline(raw.head_pipeline)
+            : raw.pipeline
+                ? pipeline(raw.pipeline)
+                : null,
+        ...(changes.diffRefs ? { diffRefs: changes.diffRefs } : {}),
+        ...(raw.source_project_id !== undefined ? { sourceProjectId: raw.source_project_id } : {}),
+        ...(raw.detailed_merge_status ? { mergeStatus: raw.detailed_merge_status } : {}),
+        ...(raw.has_conflicts === true ? { hasConflicts: true } : {}),
+        ...(raw.blocking_discussions_resolved === false ? { blockingDiscussionsResolved: false } : {}),
+        files: changes.files,
+        commentsTruncated: truncated,
+        filesTruncated: changes.filesTruncated,
+        ...(changes.changedFilesCapped ? { changedFilesCapped: true } : {}),
+    };
+}

package/packages/server/modules/gitlab/navigation.js

@@ -0,0 +1,187 @@
+import { GITLAB_PREFIX } from "../../../core/modules/gitlab/index.js";
+import { HttpError } from "../http/index.js";
+import { gitlabRequest, gitlabTarget } from "./api.js";
+const PAGE_SIZE = 100;
+const ENTRY_LIMIT = 100;
+function browseParts(path) {
+    if (!path.startsWith(GITLAB_PREFIX))
+        throw new HttpError(400, "Укажите путь gl:/<instance> или gl:/<instance>/<group>");
+    const rest = path.slice(GITLAB_PREFIX.length).replace(/\/+$/, "");
+    const [authority = "", ...segments] = rest.split("/");
+    if (!authority)
+        throw new HttpError(400, "Укажите путь gl:/<instance> или gl:/<instance>/<group>");
+    if (segments.some((segment) => !segment || segment === "." || segment === ".." || /[\\\0?#]/.test(segment)))
+        throw new HttpError(400, "Неверный путь группы GitLab");
+    return { authority, segments };
+}
+function hasNext(headers, page, count) {
+    const raw = headers.get("X-Next-Page");
+    if (raw !== null) {
+        const next = Number(raw);
+        return Number.isInteger(next) && next > page;
+    }
+    return count === PAGE_SIZE;
+}
+async function apiRequest(target, path) {
+    return gitlabRequest(target.base, path, target.token, { tokenType: target.tokenType });
+}
+/** Private namespaces are simply absent from hints instead of breaking the whole suggestion list. */
+async function hint(run) {
+    try {
+        return await run();
+    }
+    catch (error) {
+        if (error instanceof HttpError && (error.status === 401 || error.status === 403))
+            return null;
+        throw error;
+    }
+}
+/** Reads pages until the entry limit, reporting whether more rows are available. */
+async function collect(target, pathForPage, limit = ENTRY_LIMIT) {
+    const rows = [];
+    let page = 1;
+    for (;;) {
+        const response = await apiRequest(target, pathForPage(page));
+        const pageRows = Array.isArray(response.data) ? response.data : [];
+        for (const row of pageRows) {
+            if (rows.length >= limit)
+                return { rows, truncated: true };
+            rows.push(row);
+        }
+        if (!hasNext(response.headers, page, pageRows.length))
+            return { rows, truncated: false };
+        if (rows.length >= limit)
+            return { rows, truncated: true };
+        page++;
+    }
+}
+function rowName(row) {
+    const full = rowFullPath(row);
+    return row.value.name || full.split("/").pop() || full;
+}
+function rowFullPath(row) {
+    if (row.kind === "group")
+        return row.value.full_path || row.value.path || String(row.value.id);
+    return row.value.path_with_namespace || row.value.path || row.value.name || "";
+}
+function rowEntry(row, instance) {
+    return {
+        name: rowName(row),
+        path: `${GITLAB_PREFIX}${instance}/${rowFullPath(row)}`,
+    };
+}
+function sortRows(rows) {
+    return [...rows].sort((left, right) => Number(left.kind === "project") - Number(right.kind === "project") ||
+        rowName(left).localeCompare(rowName(right), undefined, { sensitivity: "base" }));
+}
+function filterRows(rows, fragment) {
+    if (!fragment)
+        return rows;
+    const prefix = fragment.toLowerCase();
+    return rows.filter((row) => {
+        if (rowName(row).toLowerCase().startsWith(prefix))
+            return true;
+        const slug = rowFullPath(row).split("/").pop() || "";
+        return slug.toLowerCase().startsWith(prefix);
+    });
+}
+function toListing(rows, target, listingPath, more = false) {
+    const sorted = sortRows(rows);
+    return {
+        path: listingPath,
+        entries: sorted.slice(0, ENTRY_LIMIT).map((row) => rowEntry(row, target.instance)),
+        truncated: more || sorted.length > ENTRY_LIMIT,
+    };
+}
+async function rootRows(target) {
+    const qualified = target.token ? "membership=true&" : "";
+    const [groups, projects] = await Promise.all([
+        hint(() => apiRequest(target, `/groups?${qualified}per_page=${PAGE_SIZE}&order_by=name`)),
+        hint(() => apiRequest(target, `/projects?${qualified}per_page=${PAGE_SIZE}&order_by=last_activity_at`)),
+    ]);
+    const rows = [
+        ...(groups?.data ?? []).map((value) => ({ kind: "group", value })),
+        ...(projects?.data ?? []).map((value) => ({ kind: "project", value })),
+    ];
+    return {
+        rows,
+        truncated: rows.length > ENTRY_LIMIT ||
+            (groups !== null && hasNext(groups.headers, 1, groups.data.length)) ||
+            (projects !== null && hasNext(projects.headers, 1, projects.data.length)),
+    };
+}
+async function group(parts, target) {
+    const name = parts.join("/");
+    try {
+        return await apiRequest(target, `/groups/${encodeURIComponent(name)}`).then((response) => response.data);
+    }
+    catch (error) {
+        if (error instanceof HttpError && [401, 403, 404].includes(error.status))
+            return null;
+        throw error;
+    }
+}
+async function groupRows(value, target) {
+    const [subgroups, projects] = await Promise.all([
+        collect(target, (page) => `/groups/${value.id}/subgroups?per_page=${PAGE_SIZE}&page=${page}&order_by=name`),
+        collect(target, (page) => `/groups/${value.id}/projects?per_page=${PAGE_SIZE}&page=${page}&order_by=name`),
+    ]);
+    return {
+        rows: [
+            ...subgroups.rows.map((row) => ({ kind: "group", value: row })),
+            ...projects.rows.map((row) => ({ kind: "project", value: row })),
+        ],
+        truncated: subgroups.truncated || projects.truncated,
+    };
+}
+async function userRows(username, target) {
+    const users = await hint(() => apiRequest(target, `/users?username=${encodeURIComponent(username)}`));
+    const user = users?.data.find((candidate) => candidate.username?.toLowerCase() === username.toLowerCase());
+    if (!user)
+        return { rows: [], truncated: false };
+    const projects = await collect(target, (page) => `/users/${user.id}/projects?per_page=${PAGE_SIZE}&page=${page}`);
+    return {
+        rows: projects.rows.map((row) => ({ kind: "project", value: row })),
+        truncated: projects.truncated,
+    };
+}
+/**
+ * Hints for the `gl:/<instance>/<group…>` path bar. The first segment after `gl:/` is the
+ * instance authority; the server only reaches gitlab.com or the configured instance.
+ */
+export async function browseGitlabDirectories(path, complete) {
+    const { authority, segments } = browseParts(path);
+    // A throwaway repository path lets the allowlist and token rules stay in api.ts.
+    const target = await gitlabTarget(`${authority}/x/y`);
+    if (!segments.length) {
+        const listing = await rootRows(target);
+        return toListing(listing.rows, target, `${GITLAB_PREFIX}${target.instance}`, listing.truncated);
+    }
+    const requested = segments.join("/");
+    const groupValue = await group(segments, target);
+    if (groupValue) {
+        const listing = await groupRows(groupValue, target);
+        return toListing(listing.rows, target, `${GITLAB_PREFIX}${target.instance}/${requested}`, listing.truncated);
+    }
+    // A one-segment path may be a personal namespace rather than a group: `gl:/host/username`.
+    if (!complete && segments.length === 1) {
+        const user = await userRows(segments[0], target);
+        return toListing(user.rows, target, `${GITLAB_PREFIX}${target.instance}/${requested}`, user.truncated);
+    }
+    if (!complete)
+        throw new HttpError(404, "Группа GitLab не найдена");
+    const fragment = segments[segments.length - 1];
+    const parentSegments = segments.slice(0, -1);
+    const parent = parentSegments.length ? await group(parentSegments, target) : null;
+    if (!parentSegments.length || parent) {
+        const listing = parent ? await groupRows(parent, target) : await rootRows(target);
+        const filtered = filterRows(listing.rows, fragment);
+        // A one-segment fragment may be a personal namespace instead of a group at the root.
+        if (filtered.length || parentSegments.length)
+            return toListing(filtered, target, `${GITLAB_PREFIX}${target.instance}/${requested}`, listing.truncated);
+    }
+    const username = segments[0];
+    const user = await userRows(username, target);
+    const filtered = filterRows(user.rows, segments.length > 1 ? fragment : "");
+    return toListing(filtered, target, `${GITLAB_PREFIX}${target.instance}/${requested}`, user.truncated);
+}