@nervekit/orchestrator 0.1.0 → 0.2.0

package/dist/git/git-service.js

@@ -1,716 +0,0 @@
-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