@nervekit/orchestrator 0.1.0

package/dist/git/git-service.js

@@ -0,0 +1,716 @@
+import { execFile } from "node:child_process";
+import { existsSync } from "node:fs";
+import { readdir } from "node:fs/promises";
+import { basename, join, resolve, sep } from "node:path";
+import { promisify } from "node:util";
+import { HttpError } from "../http/errors.js";
+import { parsePorcelainV2, parseShortstat } from "./git-status.js";
+const execFileAsync = promisify(execFile);
+const COMMAND_TIMEOUT_MS = 20_000;
+const MAX_BUFFER = 16 * 1024 * 1024;
+const MAX_DISCOVERY_DEPTH = 2;
+const SKIP_DIRS = new Set(["node_modules", ".git", "dist", "build", ".next"]);
+export class GitCommandError extends Error {
+    command;
+    code;
+    stderr;
+    constructor(command, code, stderr) {
+        super(stderr.trim() || `${command} failed`);
+        this.command = command;
+        this.code = code;
+        this.stderr = stderr;
+        this.name = "GitCommandError";
+    }
+}
+export class GitService {
+    getProject;
+    constructor(getProject) {
+        this.getProject = getProject;
+    }
+    // --- low-level exec ---
+    async run(bin, cwd, args) {
+        try {
+            const { stdout, stderr } = await execFileAsync(bin, args, {
+                cwd,
+                timeout: COMMAND_TIMEOUT_MS,
+                maxBuffer: MAX_BUFFER,
+            });
+            return { stdout, stderr };
+        }
+        catch (error) {
+            const err = error;
+            if (err.code === "ENOENT") {
+                throw new GitCommandError(bin, null, `${bin} executable not found`);
+            }
+            const code = typeof err.code === "number" ? err.code : null;
+            throw new GitCommandError(`${bin} ${args[0] ?? ""}`, code, err.stderr ?? err.message);
+        }
+    }
+    runGit(cwd, args) {
+        return this.run("git", cwd, args);
+    }
+    runGh(cwd, args) {
+        return this.run("gh", cwd, args);
+    }
+    /** Resolve and contain a repo dir relative to the project dir. */
+    resolveRepoDir(projectId, relativePath) {
+        const project = this.getProject(projectId);
+        const root = resolve(project.dir);
+        const target = resolve(root, relativePath === "." ? "" : relativePath);
+        if (target !== root && !target.startsWith(`${root}${sep}`)) {
+            throw new HttpError(400, "GIT_REPO_OUT_OF_SCOPE", "Repository path is outside the project directory.");
+        }
+        if (!existsSync(join(target, ".git"))) {
+            // .git may be a file (worktrees/submodules) — fall back to git check.
+        }
+        return target;
+    }
+    async isRepo(dir) {
+        try {
+            const { stdout } = await this.runGit(dir, [
+                "rev-parse",
+                "--is-inside-work-tree",
+            ]);
+            return stdout.trim() === "true";
+        }
+        catch {
+            return false;
+        }
+    }
+    // --- discovery ---
+    async discoverRepos(projectId) {
+        const project = this.getProject(projectId);
+        const root = resolve(project.dir);
+        if (await this.isRepo(root)) {
+            return {
+                projectIsRepo: true,
+                repos: [await this.summarizeRepo(root, ".", project.name)],
+            };
+        }
+        const repoDirs = await this.walkForRepos(root, root, 0);
+        const repos = [];
+        for (const dir of repoDirs) {
+            const relativePath = dir.slice(root.length + 1) || ".";
+            try {
+                repos.push(await this.summarizeRepo(dir, relativePath, basename(dir)));
+            }
+            catch {
+                // Skip repos we cannot summarize (corrupt/unreadable).
+            }
+        }
+        repos.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+        return { projectIsRepo: false, repos };
+    }
+    async walkForRepos(root, dir, depth) {
+        if (depth > MAX_DISCOVERY_DEPTH)
+            return [];
+        let entries;
+        try {
+            entries = await readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return [];
+        }
+        const found = [];
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            if (entry.name.startsWith(".") || SKIP_DIRS.has(entry.name))
+                continue;
+            const childDir = join(dir, entry.name);
+            if (existsSync(join(childDir, ".git"))) {
+                // Identified as a repo; do not descend further into it.
+                found.push(childDir);
+                continue;
+            }
+            found.push(...(await this.walkForRepos(root, childDir, depth + 1)));
+        }
+        return found;
+    }
+    async summarizeRepo(repoDir, relativePath, name) {
+        const { stdout } = await this.runGit(repoDir, [
+            "status",
+            "--porcelain=v2",
+            "--branch",
+        ]);
+        const { branch, files } = parsePorcelainV2(stdout);
+        const baseBranch = await this.detectBaseBranch(repoDir);
+        let hasRemote = false;
+        try {
+            hasRemote =
+                (await this.runGit(repoDir, ["remote"])).stdout.trim().length > 0;
+        }
+        catch {
+            hasRemote = false;
+        }
+        const onBaseBranch = branch.head === baseBranch;
+        return {
+            relativePath,
+            absDir: repoDir,
+            name,
+            isRepo: true,
+            currentBranch: branch.head,
+            detached: branch.detached,
+            ahead: branch.upstream ? (branch.ahead ?? 0) : null,
+            behind: branch.upstream ? (branch.behind ?? 0) : null,
+            hasUpstream: branch.upstream !== null,
+            hasRemote,
+            baseBranch,
+            onBaseBranch,
+            mergedToBase: await this.mergedToBase(repoDir, baseBranch, {
+                currentBranch: branch.head,
+                detached: branch.detached,
+                onBaseBranch,
+            }),
+            dirty: files.length > 0,
+            changeCount: files.length,
+        };
+    }
+    repoName(projectId, relativePath) {
+        if (relativePath === ".")
+            return this.getProject(projectId).name;
+        return basename(relativePath);
+    }
+    // --- overview ---
+    async overview(projectId, relativePath) {
+        const repoDir = this.resolveRepoDir(projectId, relativePath);
+        const repo = await this.summarizeRepo(repoDir, relativePath, this.repoName(projectId, relativePath));
+        const { stdout: statusOut } = await this.runGit(repoDir, [
+            "status",
+            "--porcelain=v2",
+        ]);
+        const { files } = parsePorcelainV2(statusOut);
+        const stagedCount = files.filter((f) => f.staged).length;
+        const untrackedCount = files.filter((f) => f.untracked).length;
+        const unstagedCount = files.filter((f) => !f.untracked && f.worktree !== " ").length;
+        const unstaged = parseShortstat((await this.runGit(repoDir, ["diff", "--shortstat"])).stdout);
+        const staged = parseShortstat((await this.runGit(repoDir, ["diff", "--staged", "--shortstat"])).stdout);
+        return {
+            repo,
+            baseBranch: repo.baseBranch,
+            onBaseBranch: repo.onBaseBranch,
+            files,
+            stagedCount,
+            unstagedCount,
+            untrackedCount,
+            insertions: unstaged.insertions + staged.insertions,
+            deletions: unstaged.deletions + staged.deletions,
+            recentCommits: await this.recentCommits(repoDir),
+        };
+    }
+    async recentCommits(repoDir) {
+        try {
+            const { stdout } = await this.runGit(repoDir, [
+                "log",
+                "-n",
+                "10",
+                "--pretty=%h%x00%s%x00%cr",
+            ]);
+            return stdout
+                .split("\n")
+                .filter((line) => line.length > 0)
+                .map((line) => {
+                const [hash, subject, relativeDate] = line.split("\u0000");
+                return {
+                    hash: hash ?? "",
+                    subject: subject ?? "",
+                    relativeDate: relativeDate ?? "",
+                };
+            });
+        }
+        catch {
+            return [];
+        }
+    }
+    async listBranches(projectId, relativePath) {
+        const repoDir = this.resolveRepoDir(projectId, relativePath);
+        const { stdout } = await this.runGit(repoDir, [
+            "for-each-ref",
+            "--format=%(refname)%00%(refname:short)%00%(upstream:short)%00%(HEAD)",
+            "refs/heads",
+            "refs/remotes",
+        ]);
+        const branches = stdout
+            .split("\n")
+            .filter((line) => line.length > 0)
+            .map((line) => {
+            const [refname, shortName, upstream, head] = line.split("\u0000");
+            if (!refname || !shortName)
+                return null;
+            if (refname.startsWith("refs/remotes/") &&
+                shortName.endsWith("/HEAD")) {
+                return null;
+            }
+            return {
+                name: shortName,
+                current: head === "*",
+                remote: refname.startsWith("refs/remotes/"),
+                upstream: upstream && upstream.length > 0 ? upstream : null,
+            };
+        })
+            .filter((branch) => branch !== null)
+            .sort((a, b) => {
+            if (a.current !== b.current)
+                return a.current ? -1 : 1;
+            if (a.remote !== b.remote)
+                return a.remote ? 1 : -1;
+            return a.name.localeCompare(b.name);
+        });
+        return { branches };
+    }
+    async detectBaseBranch(repoDir) {
+        try {
+            const { stdout } = await this.runGit(repoDir, [
+                "symbolic-ref",
+                "--quiet",
+                "refs/remotes/origin/HEAD",
+            ]);
+            const ref = stdout.trim();
+            if (ref.startsWith("refs/remotes/origin/")) {
+                return ref.slice("refs/remotes/origin/".length);
+            }
+        }
+        catch {
+            // fall through to probing
+        }
+        for (const candidate of ["main", "master", "develop"]) {
+            if (await this.branchExists(repoDir, candidate))
+                return candidate;
+        }
+        try {
+            const { stdout } = await this.runGit(repoDir, [
+                "rev-parse",
+                "--abbrev-ref",
+                "HEAD",
+            ]);
+            return stdout.trim() || "main";
+        }
+        catch {
+            return "main";
+        }
+    }
+    async branchExists(repoDir, name) {
+        try {
+            await this.runGit(repoDir, [
+                "rev-parse",
+                "--verify",
+                "--quiet",
+                `refs/heads/${name}`,
+            ]);
+            return true;
+        }
+        catch {
+            try {
+                await this.runGit(repoDir, [
+                    "rev-parse",
+                    "--verify",
+                    "--quiet",
+                    `refs/remotes/origin/${name}`,
+                ]);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        }
+    }
+    async comparisonBaseRef(repoDir, baseBranch) {
+        for (const candidate of [
+            `refs/remotes/origin/${baseBranch}`,
+            `refs/heads/${baseBranch}`,
+            baseBranch,
+        ]) {
+            try {
+                await this.runGit(repoDir, [
+                    "rev-parse",
+                    "--verify",
+                    "--quiet",
+                    `${candidate}^{commit}`,
+                ]);
+                return candidate;
+            }
+            catch {
+                // Try the next possible ref.
+            }
+        }
+        return baseBranch;
+    }
+    async mergedToBase(repoDir, baseBranch, state) {
+        if (state.detached || state.onBaseBranch || !state.currentBranch) {
+            return false;
+        }
+        const baseRef = await this.comparisonBaseRef(repoDir, baseBranch);
+        try {
+            await this.runGit(repoDir, [
+                "merge-base",
+                "--is-ancestor",
+                "HEAD",
+                baseRef,
+            ]);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    // --- workflow mutations ---
+    async createBranch(projectId, relativePath, name) {
+        const repoDir = this.resolveRepoDir(projectId, relativePath);
+        try {
+            await this.runGit(repoDir, ["check-ref-format", "--branch", name]);
+        }
+        catch {
+            throw new HttpError(400, "GIT_INVALID_BRANCH_NAME", `'${name}' is not a valid git branch name.`);
+        }
+        await this.mapGit(() => this.runGit(repoDir, ["switch", "-c", name]));
+        return {
+            repo: await this.summarizeRepo(repoDir, relativePath, this.repoName(projectId, relativePath)),
+        };
+    }
+    async switchBranch(projectId, relativePath, name) {
+        const repoDir = this.resolveRepoDir(projectId, relativePath);
+        const branches = await this.listBranches(projectId, relativePath);
+        const target = branches.branches.find((branch) => branch.name === name);
+        if (!target) {
+            throw new HttpError(404, "GIT_BRANCH_NOT_FOUND", `Branch '${name}' was not found.`);
+        }
+        const args = target.remote ? ["switch", "--track", name] : ["switch", name];
+        await this.mapGit(() => this.runGit(repoDir, args));
+        return {
+            repo: await this.summarizeRepo(repoDir, relativePath, this.repoName(projectId, relativePath)),
+        };
+    }
+    async stageFile(projectId, relativePath, path) {
+        const repoDir = this.resolveRepoDir(projectId, relativePath);
+        await this.mapGit(() => this.runGit(repoDir, ["add", "--", path]));
+        return {
+            repo: await this.summarizeRepo(repoDir, relativePath, this.repoName(projectId, relativePath)),
+        };
+    }
+    async unstageFile(projectId, relativePath, path) {
+        const repoDir = this.resolveRepoDir(projectId, relativePath);
+        await this.mapGit(() => this.runGit(repoDir, ["restore", "--staged", "--", path]));
+        return {
+            repo: await this.summarizeRepo(repoDir, relativePath, this.repoName(projectId, relativePath)),
+        };
+    }
+    async discardFile(projectId, relativePath, path) {
+        const repoDir = this.resolveRepoDir(projectId, relativePath);
+        const before = parsePorcelainV2((await this.runGit(repoDir, ["status", "--porcelain=v2"])).stdout).files.find((file) => file.path === path || file.renamedFrom === path);
+        try {
+            await this.runGit(repoDir, ["restore", "--staged", "--", path]);
+        }
+        catch {
+            // The path may not be staged; continue with worktree cleanup.
+        }
+        if (!before?.untracked) {
+            try {
+                await this.runGit(repoDir, ["restore", "--worktree", "--", path]);
+            }
+            catch {
+                // Newly-added or deleted paths may require git clean instead.
+            }
+        }
+        await this.mapGit(() => this.runGit(repoDir, ["clean", "-f", "--", path]));
+        return {
+            repo: await this.summarizeRepo(repoDir, relativePath, this.repoName(projectId, relativePath)),
+        };
+    }
+    async syncBranch(projectId, relativePath) {
+        const repoDir = this.resolveRepoDir(projectId, relativePath);
+        const repo = await this.summarizeRepo(repoDir, relativePath, this.repoName(projectId, relativePath));
+        if (repo.detached || !repo.currentBranch) {
+            throw new HttpError(409, "GIT_DETACHED_HEAD", "Cannot sync a detached HEAD. Check out a branch first.");
+        }
+        if (!repo.hasRemote) {
+            throw new HttpError(409, "GIT_NO_REMOTE", "This repository does not have a remote configured.");
+        }
+        if (!repo.hasUpstream) {
+            await this.mapGit(() => this.runGit(repoDir, [
+                "push",
+                "-u",
+                "origin",
+                repo.currentBranch ?? "",
+            ]));
+        }
+        else {
+            if ((repo.behind ?? 0) > 0) {
+                const { files } = parsePorcelainV2((await this.runGit(repoDir, ["status", "--porcelain=v2"])).stdout);
+                if (files.length > 0) {
+                    throw new HttpError(409, "GIT_DIRTY_WORKTREE", "Working tree has uncommitted changes. Commit or stash them before syncing.");
+                }
+                await this.mapGit(() => this.runGit(repoDir, ["pull", "--ff-only"]));
+            }
+            if ((repo.ahead ?? 0) > 0) {
+                await this.mapGit(() => this.runGit(repoDir, ["push"]));
+            }
+        }
+        return {
+            repo: await this.summarizeRepo(repoDir, relativePath, this.repoName(projectId, relativePath)),
+        };
+    }
+    async push(projectId, relativePath) {
+        const repoDir = this.resolveRepoDir(projectId, relativePath);
+        const { stdout: branchOut } = await this.runGit(repoDir, [
+            "rev-parse",
+            "--abbrev-ref",
+            "HEAD",
+        ]);
+        const branch = branchOut.trim();
+        if (!branch || branch === "HEAD") {
+            throw new HttpError(409, "GIT_DETACHED_HEAD", "Cannot push from a detached HEAD. Check out a branch first.");
+        }
+        const args = (await this.hasUpstream(repoDir))
+            ? ["push"]
+            : ["push", "-u", "origin", branch];
+        await this.mapGit(() => this.runGit(repoDir, args));
+        return {
+            repo: await this.summarizeRepo(repoDir, relativePath, this.repoName(projectId, relativePath)),
+        };
+    }
+    async pull(projectId, relativePath) {
+        const repoDir = this.resolveRepoDir(projectId, relativePath);
+        if (!(await this.hasUpstream(repoDir))) {
+            throw new HttpError(409, "GIT_NO_UPSTREAM", "Current branch has no upstream to pull from.");
+        }
+        const { files } = parsePorcelainV2((await this.runGit(repoDir, ["status", "--porcelain=v2"])).stdout);
+        if (files.length > 0) {
+            throw new HttpError(409, "GIT_DIRTY_WORKTREE", "Working tree has uncommitted changes. Commit or stash them before pulling.");
+        }
+        await this.mapGit(() => this.runGit(repoDir, ["pull", "--ff-only"]));
+        return {
+            repo: await this.summarizeRepo(repoDir, relativePath, this.repoName(projectId, relativePath)),
+        };
+    }
+    async fetch(projectId, relativePath) {
+        const repoDir = this.resolveRepoDir(projectId, relativePath);
+        await this.mapGit(() => this.runGit(repoDir, ["fetch", "--prune"]));
+        return {
+            repo: await this.summarizeRepo(repoDir, relativePath, this.repoName(projectId, relativePath)),
+        };
+    }
+    async hasUpstream(repoDir) {
+        try {
+            await this.runGit(repoDir, [
+                "rev-parse",
+                "--abbrev-ref",
+                "--symbolic-full-name",
+                "@{u}",
+            ]);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    // --- GitHub via gh ---
+    async githubStatus(projectId, relativePath) {
+        const repoDir = this.resolveRepoDir(projectId, relativePath);
+        try {
+            await this.runGh(repoDir, ["--version"]);
+        }
+        catch {
+            return {
+                available: false,
+                authenticated: false,
+                login: null,
+                reason: "GitHub CLI (gh) is not installed.",
+            };
+        }
+        try {
+            const { stdout } = await this.runGh(repoDir, [
+                "api",
+                "user",
+                "--jq",
+                ".login",
+            ]);
+            const login = stdout.trim();
+            return {
+                available: true,
+                authenticated: login.length > 0,
+                login: login.length > 0 ? login : null,
+            };
+        }
+        catch (error) {
+            return {
+                available: true,
+                authenticated: false,
+                login: null,
+                reason: error instanceof GitCommandError
+                    ? "Not authenticated. Run `gh auth login`."
+                    : "GitHub authentication check failed.",
+            };
+        }
+    }
+    async listOpenPrs(projectId, relativePath) {
+        const repoDir = this.resolveRepoDir(projectId, relativePath);
+        const { stdout } = await this.mapGh(() => this.runGh(repoDir, [
+            "pr",
+            "list",
+            "--state",
+            "open",
+            "--limit",
+            "50",
+            "--json",
+            "number,title,url,state,isDraft,headRefName,baseRefName,updatedAt",
+        ]));
+        const raw = JSON.parse(stdout || "[]");
+        const prs = await Promise.all(raw.map(async (pr) => {
+            const checks = await this.prChecks(repoDir, pr.number);
+            return {
+                number: pr.number,
+                title: pr.title,
+                url: pr.url,
+                state: pr.state,
+                isDraft: pr.isDraft,
+                headRefName: pr.headRefName,
+                baseRefName: pr.baseRefName,
+                updatedAt: pr.updatedAt,
+                checks,
+            };
+        }));
+        return { prs };
+    }
+    async prChecks(repoDir, number) {
+        try {
+            const { stdout } = await this.runGh(repoDir, [
+                "pr",
+                "checks",
+                String(number),
+                "--json",
+                "name,state,link",
+            ]);
+            const raw = JSON.parse(stdout || "[]");
+            return summarizeChecks(raw);
+        }
+        catch {
+            return {
+                status: "none",
+                total: 0,
+                passed: 0,
+                failed: 0,
+                pending: 0,
+                runs: [],
+            };
+        }
+    }
+    async prDetail(projectId, relativePath, number) {
+        const repoDir = this.resolveRepoDir(projectId, relativePath);
+        const { stdout } = await this.mapGh(() => this.runGh(repoDir, [
+            "pr",
+            "view",
+            String(number),
+            "--json",
+            "number,title,url,state,isDraft,headRefName,baseRefName,updatedAt,createdAt,body,author,additions,deletions,changedFiles,files,commits,mergeable,reviewDecision",
+        ]));
+        const raw = JSON.parse(stdout || "{}");
+        const checks = await this.prChecks(repoDir, number);
+        const files = (raw.files ?? []).map((file) => ({
+            path: file.path,
+            additions: file.additions ?? 0,
+            deletions: file.deletions ?? 0,
+        }));
+        const commits = (raw.commits ?? []).map((commit) => ({
+            oid: commit.oid,
+            abbrev: commit.oid.slice(0, 7),
+            messageHeadline: commit.messageHeadline ?? "",
+            authoredDate: commit.authoredDate,
+            authorName: commit.authors?.[0]?.name,
+        }));
+        return {
+            number: raw.number,
+            title: raw.title,
+            url: raw.url,
+            state: raw.state,
+            isDraft: raw.isDraft,
+            headRefName: raw.headRefName,
+            baseRefName: raw.baseRefName,
+            updatedAt: raw.updatedAt,
+            createdAt: raw.createdAt,
+            body: raw.body ?? "",
+            author: raw.author?.login ?? null,
+            additions: raw.additions ?? 0,
+            deletions: raw.deletions ?? 0,
+            changedFiles: raw.changedFiles ?? files.length,
+            mergeable: raw.mergeable ?? null,
+            reviewDecision: raw.reviewDecision ?? null,
+            files,
+            commits,
+            checks,
+        };
+    }
+    async checkoutPr(projectId, relativePath, number) {
+        const repoDir = this.resolveRepoDir(projectId, relativePath);
+        const { files } = parsePorcelainV2((await this.runGit(repoDir, ["status", "--porcelain=v2"])).stdout);
+        if (files.length > 0) {
+            throw new HttpError(409, "GIT_DIRTY_WORKTREE", "Working tree has uncommitted changes. Commit or stash them before checking out a PR.");
+        }
+        await this.mapGh(() => this.runGh(repoDir, ["pr", "checkout", String(number)]));
+        return {
+            repo: await this.summarizeRepo(repoDir, relativePath, this.repoName(projectId, relativePath)),
+            number,
+        };
+    }
+    // --- error mapping ---
+    async mapGit(fn) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            if (error instanceof GitCommandError) {
+                throw new HttpError(409, "GIT_COMMAND_FAILED", error.message);
+            }
+            throw error;
+        }
+    }
+    async mapGh(fn) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            if (error instanceof GitCommandError) {
+                const status = error.code === null ? 503 : 409;
+                throw new HttpError(status, "GH_COMMAND_FAILED", error.message);
+            }
+            throw error;
+        }
+    }
+}
+export function summarizeChecks(runs) {
+    let passed = 0;
+    let failed = 0;
+    let pending = 0;
+    const normalized = runs.map((run) => {
+        const state = run.state.toUpperCase();
+        if (["SUCCESS", "NEUTRAL", "SKIPPED"].includes(state))
+            passed += 1;
+        else if ([
+            "FAILURE",
+            "ERROR",
+            "CANCELLED",
+            "TIMED_OUT",
+            "ACTION_REQUIRED",
+        ].includes(state))
+            failed += 1;
+        else
+            pending += 1;
+        return {
+            name: run.name,
+            status: state.toLowerCase(),
+            conclusion: state.toLowerCase(),
+            url: run.link,
+        };
+    });
+    const total = normalized.length;
+    let status = "none";
+    if (total > 0) {
+        if (failed > 0)
+            status = "failing";
+        else if (pending > 0)
+            status = "pending";
+        else
+            status = "passing";
+    }
+    return { status, total, passed, failed, pending, runs: normalized };
+}
+//# sourceMappingURL=git-service.js.map