@ai-projector/ide 0.0.0-stage → 0.11.0

package/packages/server/modules/workspace/git-branches.js

@@ -0,0 +1,159 @@
+import { realpath } from "node:fs/promises";
+import { HttpError } from "../http/index.js";
+import { git, serializeGitWrite } from "./git.js";
+const FIELD = "\x1f";
+const refFormat = [
+    "%(HEAD)",
+    "%(refname)",
+    "%(refname:short)",
+    "%(upstream:short)",
+    "%(upstream:track,nobracket)",
+    "%(objectname:short)",
+    "%(committerdate:iso-strict)",
+    "%(contents:subject)",
+].join("%1f");
+async function optional(root, args) {
+    return git(root, args).then((value) => value.trim(), () => "");
+}
+/** Git's own words are the most useful explanation, e.g. which files block a checkout. */
+async function run(root, args) {
+    try {
+        return await git(root, args);
+    }
+    catch (error) {
+        const text = String(error.stderr ?? error.message);
+        const lines = text
+            .split("\n")
+            .map((line) => line.trim())
+            .filter(Boolean);
+        throw new HttpError(409, lines.slice(0, 4).join("\n") || "Операция Git не выполнена");
+    }
+}
+export async function projectBranches(root) {
+    const empty = {
+        available: false,
+        current: "",
+        detached: false,
+        remotes: [],
+        branches: [],
+    };
+    if (await git(root, ["rev-parse", "--show-toplevel"]).then(() => false, () => true))
+        return empty;
+    const [rows, merged, symbolic, short, remotes] = await Promise.all([
+        optional(root, [
+            "for-each-ref",
+            `--format=${refFormat}`,
+            "--sort=-committerdate",
+            "refs/heads",
+            "refs/remotes",
+        ]),
+        optional(root, ["for-each-ref", "--merged=HEAD", "--format=%(refname:short)", "refs/heads"]),
+        optional(root, ["symbolic-ref", "--short", "-q", "HEAD"]),
+        optional(root, ["rev-parse", "--short", "HEAD"]),
+        optional(root, ["remote"]),
+    ]);
+    const mergedNames = new Set(merged.split("\n").filter(Boolean));
+    const branches = [];
+    for (const row of rows.split("\n")) {
+        if (!row)
+            continue;
+        const [head = "", ref = "", name = "", upstream = "", track = "", hash = "", date = "", subject = "",] = row.split(FIELD);
+        if (ref.endsWith("/HEAD"))
+            continue;
+        const local = ref.startsWith("refs/heads/");
+        branches.push({
+            name,
+            kind: local ? "local" : "remote",
+            current: head === "*",
+            upstream,
+            gone: track === "gone",
+            ahead: Number(/ahead (\d+)/.exec(track)?.[1] ?? 0),
+            behind: Number(/behind (\d+)/.exec(track)?.[1] ?? 0),
+            merged: local && mergedNames.has(name),
+            hash,
+            subject,
+            date,
+        });
+    }
+    // Current branch first, then local branches, then remote ones; each by recency.
+    const rank = (branch) => (branch.current ? 0 : branch.kind === "local" ? 1 : 2);
+    branches.sort((a, b) => rank(a) - rank(b));
+    return {
+        available: true,
+        current: symbolic || short,
+        detached: !symbolic,
+        remotes: remotes.split("\n").filter(Boolean),
+        branches,
+    };
+}
+async function validName(root, name) {
+    if (typeof name !== "string" || !name.trim())
+        throw new HttpError(400, "Укажите имя ветки");
+    const valid = await git(root, ["check-ref-format", "--branch", name]).then(() => true, () => false);
+    if (!valid || name === "HEAD")
+        throw new HttpError(400, `Недопустимое имя ветки: ${name}`);
+    return name;
+}
+/** Branch operations; names are resolved against the real branch list, never passed through blindly. */
+export async function mutateProjectBranch(root, action, input) {
+    if (!["checkout", "create", "rename", "delete"].includes(action))
+        throw new HttpError(400, "Неизвестное действие с веткой");
+    const base = await realpath(root);
+    return serializeGitWrite(base, async () => {
+        const current = await projectBranches(base);
+        if (!current.available)
+            throw new HttpError(404, "Здесь нет Git-репозитория");
+        const find = (name, kind) => current.branches.find((branch) => branch.name === name && (!kind || branch.kind === kind));
+        if (action === "create") {
+            const name = await validName(base, input.name);
+            if (find(name, "local"))
+                throw new HttpError(409, `Ветка ${name} уже существует`);
+            let from = "HEAD";
+            if (input.from) {
+                if (!find(input.from) && !/^[0-9a-f]{7,40}$/.test(input.from))
+                    throw new HttpError(400, "Начало ветки: укажите ветку или хеш коммита");
+                from = input.from;
+                if (!(await optional(base, ["rev-parse", "--verify", "--quiet", `${from}^{commit}`])))
+                    throw new HttpError(404, "Коммит не найден");
+            }
+            if (!(await optional(base, ["rev-parse", "--verify", "--quiet", "HEAD"])))
+                throw new HttpError(409, "Сначала создайте первый коммит");
+            await run(base, input.checkout === false ? ["branch", name, from] : ["switch", "-c", name, from]);
+        }
+        else {
+            const branch = find(input.name);
+            if (!branch)
+                throw new HttpError(404, "Ветка не найдена. Обновите список.");
+            if (action === "checkout") {
+                if (branch.current)
+                    return current;
+                if (branch.kind === "local")
+                    await run(base, ["switch", branch.name]);
+                else {
+                    const local = branch.name.slice(branch.name.indexOf("/") + 1);
+                    if (find(local, "local"))
+                        await run(base, ["switch", local]);
+                    else
+                        await run(base, ["switch", "--track", branch.name]);
+                }
+            }
+            else if (branch.kind !== "local") {
+                throw new HttpError(409, "Ветки удалённого репозитория не изменяются");
+            }
+            else if (action === "rename") {
+                const newName = await validName(base, input.newName);
+                if (find(newName, "local"))
+                    throw new HttpError(409, `Ветка ${newName} уже существует`);
+                await run(base, ["branch", "-m", branch.name, newName]);
+            }
+            else {
+                if (branch.current)
+                    throw new HttpError(409, "Нельзя удалить текущую ветку");
+                if (!branch.merged && !input.force)
+                    throw new HttpError(409, `Ветка ${branch.name} не слита в текущую`);
+                await run(base, ["branch", "-D", branch.name]);
+            }
+        }
+        return projectBranches(base);
+    });
+}

package/packages/server/modules/workspace/git-compare.js

@@ -0,0 +1,121 @@
+import { HttpError } from "../http/index.js";
+import { MAX_TEXT_BYTES, commitChangeKind, isExcludedPath, } from "../../../core/modules/workspace/index.js";
+import { git, gitText } from "./git.js";
+import { excludePatterns } from "./files-exclude.js";
+import { resolveRevision, validateRelativePath } from "./git-tree.js";
+const MAX_CHANGES = 5000;
+async function projectPrefix(root) {
+    return (await git(root, ["rev-parse", "--show-prefix"])).trim();
+}
+function relativePath(path, prefix) {
+    if (!prefix)
+        return path;
+    return path.startsWith(prefix) ? path.slice(prefix.length) : "";
+}
+/** `--numstat -z` emits `add\tdel\tpath`, or `add\tdel\t\0old\0new` for a rename. */
+function parseNumstat(raw) {
+    const result = new Map();
+    const tokens = raw.split("\0");
+    for (let index = 0; index < tokens.length;) {
+        const token = tokens[index++];
+        if (!token)
+            continue;
+        const [additions = "", deletions = "", inlinePath = ""] = token.split("\t");
+        let path = inlinePath;
+        if (!path) {
+            index++;
+            path = tokens[index++] ?? "";
+        }
+        if (!path)
+            continue;
+        const binary = additions === "-" || deletions === "-";
+        result.set(path, binary
+            ? { binary: true }
+            : { additions: Number(additions) || 0, deletions: Number(deletions) || 0 });
+    }
+    return result;
+}
+/**
+ * Changed paths of two commits against each other. The answer is a flat list: a comparison has no
+ * "deleted node" in a live tree, and the tree view synthesizes folders from these paths.
+ */
+export async function compareProjectChanges(root, from, to) {
+    const [fromHash, toHash] = await Promise.all([
+        resolveRevision(root, from),
+        resolveRevision(root, to),
+    ]);
+    if (fromHash === toHash)
+        return { changes: [], truncated: false };
+    const prefix = await projectPrefix(root);
+    const [statusRaw, numstatRaw, patterns] = await Promise.all([
+        git(root, ["diff", "--name-status", "-z", "-M", fromHash, toHash]),
+        git(root, ["diff", "--numstat", "-z", "-M", fromHash, toHash]),
+        excludePatterns(),
+    ]);
+    const stats = parseNumstat(numstatRaw);
+    const tokens = statusRaw.split("\0");
+    const changes = [];
+    for (let index = 0; index < tokens.length;) {
+        const status = tokens[index++];
+        if (!status)
+            continue;
+        let fromPath = "";
+        let toPath = "";
+        if (status.startsWith("R") || status.startsWith("C")) {
+            fromPath = tokens[index++] ?? "";
+            toPath = tokens[index++] ?? "";
+        }
+        else
+            toPath = tokens[index++] ?? "";
+        const path = relativePath(toPath, prefix);
+        if (!path || isExcludedPath(path, patterns))
+            continue;
+        const originalPath = fromPath && (status.startsWith("R") || status.startsWith("C"))
+            ? relativePath(fromPath, prefix)
+            : "";
+        const stat = stats.get(toPath) ?? {};
+        changes.push({
+            path,
+            kind: commitChangeKind(status[0] ?? "M"),
+            ...(originalPath ? { originalPath } : {}),
+            ...stat,
+        });
+    }
+    return { changes: changes.slice(0, MAX_CHANGES), truncated: changes.length > MAX_CHANGES };
+}
+/**
+ * Two text sides of one path between commits. A missing side is an empty string; renames pass the
+ * old path separately, because the comparison list knows it.
+ */
+export async function compareProjectFile(root, from, to, path, originalPath = path) {
+    validateRelativePath(path);
+    validateRelativePath(originalPath);
+    if (!path)
+        throw new HttpError(400, "Выберите файл");
+    const [fromHash, toHash] = await Promise.all([
+        resolveRevision(root, from),
+        resolveRevision(root, to),
+    ]);
+    const prefix = await projectPrefix(root);
+    const read = async (hash, file) => {
+        const spec = `${hash}:${prefix}${file}`;
+        const type = (await git(root, ["cat-file", "-t", spec]).catch(() => "")).trim();
+        if (!type)
+            return "";
+        if (type !== "blob")
+            throw new HttpError(400, "Выберите файл");
+        const size = Number((await git(root, ["cat-file", "-s", spec])).trim());
+        if (!Number.isSafeInteger(size) || size < 0)
+            throw new HttpError(404, "Файл не найден в этом снимке");
+        if (size > MAX_TEXT_BYTES)
+            throw new HttpError(413, `Файл больше ${MAX_TEXT_BYTES / 1024 / 1024} МБ: редактор не сможет его открыть`);
+        return gitText(root, hash, file);
+    };
+    const [original, modified] = await Promise.all([
+        read(fromHash, originalPath),
+        read(toHash, path),
+    ]);
+    if (!original && !modified)
+        throw new HttpError(404, "Файл не найден в этом сравнении");
+    return { path, original, modified };
+}

package/packages/server/modules/workspace/git-history.js

@@ -0,0 +1,182 @@
+import { HttpError } from "../http/index.js";
+import { validatePath } from "./paths.js";
+import { git, gitText } from "./git.js";
+const EMPTY_TREE = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
+const PAGE = 50;
+const FIELD = "\x1f";
+const logFormat = ["%H", "%P", "%an", "%ae", "%aI", "%D", "%s"].join("%x1f");
+function parseRefs(value) {
+    const refs = [];
+    for (const part of value.split(", ")) {
+        if (!part)
+            continue;
+        if (part.startsWith("HEAD -> ")) {
+            refs.push({ name: "HEAD", kind: "head" }, { name: part.slice(8), kind: "branch" });
+        }
+        else if (part === "HEAD")
+            refs.push({ name: "HEAD", kind: "head" });
+        else if (part.startsWith("tag: "))
+            refs.push({ name: part.slice(5), kind: "tag" });
+        else
+            refs.push({ name: part, kind: part.includes("/") ? "remote" : "branch" });
+    }
+    return refs;
+}
+function parseCommit(row, unpushed) {
+    const [hash = "", parents = "", author = "", email = "", date = "", refs = "", subject = ""] = row.split(FIELD);
+    return {
+        hash,
+        parents: parents ? parents.split(" ") : [],
+        subject,
+        author,
+        email,
+        date,
+        refs: parseRefs(refs),
+        unpushed: unpushed.has(hash),
+    };
+}
+async function optional(root, args) {
+    return git(root, args).then((value) => value.trim(), () => "");
+}
+async function isRepository(root) {
+    return git(root, ["rev-parse", "--show-toplevel"]).then(() => true, () => false);
+}
+/** A page of history for HEAD, or for all refs; `query` matches the message, or the author with a leading `@`. */
+export async function projectLog(root, options = {}) {
+    const empty = {
+        available: false,
+        head: "",
+        upstream: "",
+        ahead: 0,
+        behind: 0,
+        me: "",
+        commits: [],
+        next: null,
+    };
+    if (!(await isRepository(root)))
+        return empty;
+    const skip = Math.max(0, Math.floor(options.skip ?? 0));
+    const limit = Math.min(200, Math.max(1, Math.floor(options.limit ?? PAGE)));
+    const head = await optional(root, ["rev-parse", "--verify", "--quiet", "HEAD"]);
+    const [me, upstream] = await Promise.all([
+        optional(root, ["config", "user.email"]),
+        head ? optional(root, ["rev-parse", "--abbrev-ref", "@{upstream}"]) : "",
+    ]);
+    const result = { ...empty, available: true, head, me, upstream };
+    if (!head && !options.all)
+        return result;
+    const unpushed = new Set();
+    if (upstream) {
+        const [ahead, behind] = (await optional(root, ["rev-list", "--left-right", "--count", `HEAD...${upstream}`]))
+            .split(/\s+/)
+            .map(Number);
+        result.ahead = ahead || 0;
+        result.behind = behind || 0;
+        for (const hash of (await optional(root, ["rev-list", "-n", "2000", `${upstream}..HEAD`])).split("\n"))
+            if (hash)
+                unpushed.add(hash);
+    }
+    const query = options.query?.trim() ?? "";
+    const args = [
+        "log",
+        "-z",
+        "--topo-order",
+        "--decorate=short",
+        `--format=${logFormat}`,
+        `--skip=${skip}`,
+        `-n${limit + 1}`,
+        options.all ? "--all" : "HEAD",
+    ];
+    // `@name` searches authors, anything else the commit message.
+    if (query)
+        args.push("--regexp-ignore-case", "--fixed-strings", query.startsWith("@") ? `--author=${query.slice(1)}` : `--grep=${query}`);
+    args.push("--");
+    const rows = (await git(root, args)).split("\0").filter(Boolean);
+    result.commits = rows.slice(0, limit).map((row) => parseCommit(row.trim(), unpushed));
+    result.next = rows.length > limit ? skip + limit : null;
+    return result;
+}
+async function resolveCommit(root, hash) {
+    if (!/^[0-9a-f]{7,40}$/.test(hash))
+        throw new HttpError(400, "Некорректный хеш коммита");
+    const full = await optional(root, ["rev-parse", "--verify", "--quiet", `${hash}^{commit}`]);
+    if (!full)
+        throw new HttpError(404, "Коммит не найден");
+    return full;
+}
+function splitNul(value) {
+    const items = value.split("\0");
+    if (items.at(-1) === "")
+        items.pop();
+    return items;
+}
+async function commitFiles(root, base, hash) {
+    const range = [base, hash];
+    const [names, numbers] = await Promise.all([
+        git(root, ["diff", "--name-status", "-z", "-M", "--relative", ...range, "--"]),
+        git(root, ["diff", "--numstat", "-z", "-M", "--relative", ...range, "--"]),
+    ]);
+    const stats = new Map();
+    const parts = splitNul(numbers);
+    for (let i = 0; i < parts.length; i++) {
+        const [add = "", del = "", path = ""] = parts[i].split("\t");
+        // A rename is `add\tdel\t` followed by the old and the new path.
+        const target = path || ((i += 2), parts[i]);
+        const binary = add === "-";
+        stats.set(target, { additions: binary ? 0 : +add, deletions: binary ? 0 : +del, binary });
+    }
+    const files = [];
+    const items = splitNul(names);
+    for (let i = 0; i < items.length; i++) {
+        const status = items[i][0];
+        const original = status === "R" || status === "C" ? items[++i] : undefined;
+        const path = items[++i];
+        const stat = stats.get(path) ?? { additions: 0, deletions: 0, binary: false };
+        files.push({ path, originalPath: original, status, ...stat });
+    }
+    return files.sort((a, b) => a.path.localeCompare(b.path));
+}
+/** What a commit changed against its first parent, for the project folder. */
+export async function projectCommit(root, hash) {
+    const full = await resolveCommit(root, hash);
+    const meta = await git(root, [
+        "show",
+        "-s",
+        `--format=${["%H", "%P", "%an", "%ae", "%aI", "%D", "%s", "%cn", "%cI", "%b"].join("%x1f")}`,
+        full,
+    ]);
+    const [h = "", parents = "", author = "", email = "", date = "", refs = "", subject = "", cn = "", cd = "", ...body] = meta.split(FIELD);
+    const parentList = parents ? parents.split(" ") : [];
+    const files = await commitFiles(root, parentList[0] ?? EMPTY_TREE, full);
+    return {
+        hash: h,
+        parents: parentList,
+        subject,
+        author,
+        email,
+        date,
+        refs: parseRefs(refs),
+        body: body.join(FIELD).trim(),
+        committer: cn,
+        committerDate: cd,
+        additions: files.reduce((sum, file) => sum + file.additions, 0),
+        deletions: files.reduce((sum, file) => sum + file.deletions, 0),
+        files,
+    };
+}
+/** Before/after text of one file of a commit, for the diff tab. */
+export async function projectCommitComparison(root, hash, path) {
+    validatePath(path);
+    const detail = await projectCommit(root, hash);
+    const file = detail.files.find((item) => item.path === path);
+    if (!file)
+        throw new HttpError(404, "Файл не входит в этот коммит");
+    if (file.binary)
+        throw new HttpError(415, "Бинарный файл нельзя сравнить как текст");
+    const parent = detail.parents[0];
+    const original = !parent || file.status === "A" || (file.status === "C" && !file.originalPath)
+        ? ""
+        : await gitText(root, parent, file.originalPath ?? path);
+    const modified = file.status === "D" ? "" : await gitText(root, detail.hash, path);
+    return { path, original, modified, hash: detail.hash, parent: parent?.slice(0, 7) ?? "" };
+}