yepanywhere 0.5.2 → 0.6.0

package/dist/routes/git-status.js

@@ -1,5 +1,5 @@
-import { execFile } from "node:child_process";
-import { readFile } from "node:fs/promises";
+import { execFile, spawn } from "node:child_process";
+import { readFile, stat } from "node:fs/promises";
 import { extname, resolve } from "node:path";
 import { promisify } from "node:util";
 import { isUrlProjectId, } from "../../bundled/@yep-anywhere/shared/dist/index.js";
@@ -15,7 +15,13 @@ const NOT_A_GIT_REPO = {
     behind: 0,
     isClean: true,
     files: [],
+    recentCommits: [],
+    checkedRemoteAt: null,
 };
+const remoteCheckedAtByProjectPath = new Map();
+const gitOperationsByProjectPath = new Set();
+const UNTRACKED_FOLDER_FILE_LIMIT = 500;
+const GIT_DECODE_PATHS_ARGS = ["-c", "core.quotePath=false"];
 export function createGitStatusRoutes(deps) {
     const routes = new Hono();
     routes.get("/:projectId/git", async (c) => {
@@ -28,7 +34,7 @@ export function createGitStatusRoutes(deps) {
             return c.json({ error: "Project not found" }, 404);
         }
         try {
-            const result = await getGitStatus(project.path);
+            const result = await getGitStatusWithRemoteCheckTime(project.path);
             return c.json(result);
         }
         catch (err) {
@@ -38,6 +44,291 @@ export function createGitStatusRoutes(deps) {
             return c.json({ error: "Failed to get git status" }, 500);
         }
     });
+    /**
+     * GET /:projectId/git/untracked-folder?path=dir/
+     * Expand one compact untracked directory on demand.
+     */
+    routes.get("/:projectId/git/untracked-folder", async (c) => {
+        const projectId = c.req.param("projectId");
+        if (!isUrlProjectId(projectId)) {
+            return c.json({ error: "Invalid project ID format" }, 400);
+        }
+        const project = await deps.scanner.getProject(projectId);
+        if (!project) {
+            return c.json({ error: "Project not found" }, 404);
+        }
+        const path = c.req.query("path");
+        if (!path || !isValidUntrackedFolderPath(path)) {
+            return c.json({ error: "Invalid untracked folder path" }, 400);
+        }
+        try {
+            return c.json(await getUntrackedFolderInfo(project.path, path));
+        }
+        catch (err) {
+            if (isNotGitRepoError(err)) {
+                return c.json({ error: "Not a git repository" }, 400);
+            }
+            return c.json({ error: "Failed to expand untracked folder" }, 500);
+        }
+    });
+    /**
+     * POST /:projectId/git/check-remote
+     * Explicitly fetch remote refs and update the last-checked timestamp.
+     */
+    routes.post("/:projectId/git/check-remote", async (c) => {
+        const projectId = c.req.param("projectId");
+        if (!isUrlProjectId(projectId)) {
+            return c.json({ error: "Invalid project ID format" }, 400);
+        }
+        const project = await deps.scanner.getProject(projectId);
+        if (!project) {
+            return c.json({ error: "Project not found" }, 404);
+        }
+        const checkedRemoteAt = await getCheckedRemoteAt(project.path);
+        if (gitOperationsByProjectPath.has(project.path)) {
+            const result = {
+                status: "busy",
+                checkedRemoteAt,
+                gitStatus: await getGitStatusSnapshot(project.path),
+            };
+            return c.json(result);
+        }
+        gitOperationsByProjectPath.add(project.path);
+        try {
+            await runGit(project.path, ["fetch"], {
+                timeout: 30_000,
+                disableTerminalPrompt: true,
+            });
+            const nextCheckedRemoteAt = new Date().toISOString();
+            remoteCheckedAtByProjectPath.set(project.path, nextCheckedRemoteAt);
+            const result = {
+                status: "checked",
+                checkedRemoteAt: nextCheckedRemoteAt,
+                gitStatus: await getGitStatusWithRemoteCheckTime(project.path),
+            };
+            return c.json(result);
+        }
+        catch (err) {
+            if (isNotGitRepoError(err)) {
+                const result = {
+                    status: "not-a-git-repo",
+                    checkedRemoteAt: null,
+                    gitStatus: NOT_A_GIT_REPO,
+                };
+                return c.json(result);
+            }
+            const result = {
+                status: "failed",
+                checkedRemoteAt: await getCheckedRemoteAt(project.path),
+                gitStatus: await getGitStatusSnapshot(project.path),
+                detail: getGitErrorDetail(err),
+            };
+            return c.json(result);
+        }
+        finally {
+            gitOperationsByProjectPath.delete(project.path);
+        }
+    });
+    /**
+     * GET /:projectId/git/integration-options
+     * Inspect whether automatic diverged-branch options can be offered.
+     *
+     * This is intentionally read-only: it does not fetch, rebase, merge, stash, or
+     * otherwise mutate the repository.
+     */
+    routes.get("/:projectId/git/integration-options", async (c) => {
+        const projectId = c.req.param("projectId");
+        if (!isUrlProjectId(projectId)) {
+            return c.json({ error: "Invalid project ID format" }, 400);
+        }
+        const project = await deps.scanner.getProject(projectId);
+        if (!project) {
+            return c.json({ error: "Project not found" }, 404);
+        }
+        const checkedRemoteAt = await getCheckedRemoteAt(project.path);
+        if (gitOperationsByProjectPath.has(project.path)) {
+            const status = await getGitStatusSnapshot(project.path);
+            const result = {
+                ...buildGitIntegrationOptionsResult(status, checkedRemoteAt, false),
+                status: "busy",
+                canAutoRebase: false,
+                canAutoMerge: false,
+                reasons: ["operation-running"],
+            };
+            return c.json(result);
+        }
+        try {
+            const status = await getGitStatusWithRemoteCheckTime(project.path);
+            const hasSequencerState = await hasGitSequencerState(project.path);
+            return c.json(buildGitIntegrationOptionsResult(status, checkedRemoteAt, hasSequencerState));
+        }
+        catch (err) {
+            if (isNotGitRepoError(err)) {
+                const result = {
+                    status: "not-a-git-repo",
+                    checkedRemoteAt: null,
+                    gitStatus: NOT_A_GIT_REPO,
+                    canAutoRebase: false,
+                    canAutoMerge: false,
+                    reasons: ["not-a-git-repo"],
+                    ahead: 0,
+                    behind: 0,
+                    upstream: null,
+                    isClean: true,
+                    hasSequencerState: false,
+                };
+                return c.json(result);
+            }
+            const snapshot = await getGitStatusSnapshot(project.path);
+            const result = {
+                status: "failed",
+                checkedRemoteAt: await getCheckedRemoteAt(project.path),
+                gitStatus: snapshot,
+                canAutoRebase: false,
+                canAutoMerge: false,
+                reasons: ["status-unavailable"],
+                ahead: snapshot.ahead,
+                behind: snapshot.behind,
+                upstream: snapshot.upstream,
+                isClean: snapshot.isClean,
+                hasSequencerState: false,
+                detail: getGitErrorDetail(err),
+            };
+            return c.json(result);
+        }
+    });
+    /**
+     * POST /:projectId/git/pull
+     * Try a safe fast-forward pull without opening interactive prompts.
+     */
+    routes.post("/:projectId/git/pull", async (c) => {
+        const projectId = c.req.param("projectId");
+        if (!isUrlProjectId(projectId)) {
+            return c.json({ error: "Invalid project ID format" }, 400);
+        }
+        const project = await deps.scanner.getProject(projectId);
+        if (!project) {
+            return c.json({ error: "Project not found" }, 404);
+        }
+        const checkedRemoteAt = await getCheckedRemoteAt(project.path);
+        if (gitOperationsByProjectPath.has(project.path)) {
+            const result = {
+                status: "busy",
+                checkedRemoteAt,
+                gitStatus: await getGitStatusSnapshot(project.path),
+            };
+            return c.json(result);
+        }
+        gitOperationsByProjectPath.add(project.path);
+        try {
+            await runGit(project.path, ["pull", "--ff-only"], {
+                timeout: 60_000,
+                disableTerminalPrompt: true,
+            });
+            const nextCheckedRemoteAt = new Date().toISOString();
+            remoteCheckedAtByProjectPath.set(project.path, nextCheckedRemoteAt);
+            const result = {
+                status: "pulled",
+                checkedRemoteAt: nextCheckedRemoteAt,
+                gitStatus: await getGitStatusWithRemoteCheckTime(project.path),
+            };
+            return c.json(result);
+        }
+        catch (err) {
+            if (isNotGitRepoError(err)) {
+                const result = {
+                    status: "not-a-git-repo",
+                    checkedRemoteAt: null,
+                    gitStatus: NOT_A_GIT_REPO,
+                };
+                return c.json(result);
+            }
+            const result = {
+                status: "failed",
+                checkedRemoteAt: await getCheckedRemoteAt(project.path),
+                gitStatus: await getGitStatusSnapshot(project.path),
+                detail: getGitErrorDetail(err),
+            };
+            return c.json(result);
+        }
+        finally {
+            gitOperationsByProjectPath.delete(project.path);
+        }
+    });
+    /**
+     * POST /:projectId/git/push
+     * Push the current branch, publishing to origin for simple no-upstream cases.
+     */
+    routes.post("/:projectId/git/push", async (c) => {
+        const projectId = c.req.param("projectId");
+        if (!isUrlProjectId(projectId)) {
+            return c.json({ error: "Invalid project ID format" }, 400);
+        }
+        const project = await deps.scanner.getProject(projectId);
+        if (!project) {
+            return c.json({ error: "Project not found" }, 404);
+        }
+        const checkedRemoteAt = await getCheckedRemoteAt(project.path);
+        if (gitOperationsByProjectPath.has(project.path)) {
+            const result = {
+                status: "busy",
+                checkedRemoteAt,
+                gitStatus: await getGitStatusSnapshot(project.path),
+            };
+            return c.json(result);
+        }
+        gitOperationsByProjectPath.add(project.path);
+        try {
+            const status = await getGitStatusWithRemoteCheckTime(project.path);
+            const pushArgs = status.upstream
+                ? ["push"]
+                : status.branch && (await hasGitRemote(project.path, "origin"))
+                    ? ["push", "-u", "origin", "HEAD"]
+                    : null;
+            if (!pushArgs) {
+                const result = {
+                    status: "no-upstream",
+                    checkedRemoteAt,
+                    gitStatus: status,
+                };
+                return c.json(result);
+            }
+            const pushResult = await runGit(project.path, pushArgs, {
+                timeout: 60_000,
+                disableTerminalPrompt: true,
+            });
+            const result = {
+                status: status.upstream
+                    ? isPushAlreadyUpToDateOutput(pushResult)
+                        ? "up-to-date"
+                        : "pushed"
+                    : "published",
+                checkedRemoteAt: await getCheckedRemoteAt(project.path),
+                gitStatus: await getGitStatusWithRemoteCheckTime(project.path),
+            };
+            return c.json(result);
+        }
+        catch (err) {
+            if (isNotGitRepoError(err)) {
+                const result = {
+                    status: "not-a-git-repo",
+                    checkedRemoteAt: null,
+                    gitStatus: NOT_A_GIT_REPO,
+                };
+                return c.json(result);
+            }
+            const result = {
+                status: isPushRejectedError(err) ? "rejected" : "failed",
+                checkedRemoteAt: await getCheckedRemoteAt(project.path),
+                gitStatus: await getGitStatusSnapshot(project.path),
+                detail: getGitErrorDetail(err),
+            };
+            return c.json(result);
+        }
+        finally {
+            gitOperationsByProjectPath.delete(project.path);
+        }
+    });
     /**
      * POST /:projectId/git/diff
      * Get syntax-highlighted diff for a specific file.
@@ -63,6 +354,9 @@ export function createGitStatusRoutes(deps) {
         if (!path || typeof staged !== "boolean" || !status) {
             return c.json({ error: "Missing required fields: path, staged, status" }, 400);
         }
+        if (status === "?" && path.endsWith("/")) {
+            return c.json({ error: "Diff preview is not available for untracked folders" }, 400);
+        }
         try {
             const { oldContent, newContent } = await getFileVersions(project.path, path, staged, status);
             const contextLines = fullContext ? 999999 : 3;
@@ -138,23 +432,173 @@ async function getFileVersions(cwd, path, staged, status) {
     ]);
     return { oldContent: oldResult.stdout, newContent };
 }
-async function runGit(cwd, args) {
+async function runGit(cwd, args, options) {
     return execFileAsync("git", ["-C", cwd, ...args], {
         maxBuffer: 1024 * 1024,
-        timeout: 10_000,
+        timeout: options?.timeout ?? 10_000,
+        ...(options?.disableTerminalPrompt
+            ? { env: { ...process.env, GIT_TERMINAL_PROMPT: "0" } }
+            : {}),
     });
 }
+async function getCheckedRemoteAt(projectPath) {
+    return latestIsoTimestamp(remoteCheckedAtByProjectPath.get(projectPath) ?? null, await getRecordedFetchAt(projectPath));
+}
+async function getGitStatusWithRemoteCheckTime(projectPath) {
+    return getGitStatus(projectPath, await getCheckedRemoteAt(projectPath));
+}
+async function getGitStatusSnapshot(projectPath) {
+    try {
+        return await getGitStatusWithRemoteCheckTime(projectPath);
+    }
+    catch (err) {
+        if (isNotGitRepoError(err)) {
+            return NOT_A_GIT_REPO;
+        }
+        return {
+            ...NOT_A_GIT_REPO,
+            checkedRemoteAt: await getCheckedRemoteAt(projectPath),
+        };
+    }
+}
+function buildGitIntegrationOptionsResult(status, checkedRemoteAt, hasSequencerState) {
+    const reasons = [];
+    if (!status.isGitRepo) {
+        reasons.push("not-a-git-repo");
+    }
+    if (!status.branch) {
+        reasons.push("detached-head");
+    }
+    if (!status.upstream) {
+        reasons.push("missing-upstream");
+    }
+    if (!(status.ahead > 0 && status.behind > 0)) {
+        reasons.push("not-diverged");
+    }
+    if (!status.isClean) {
+        reasons.push("dirty-worktree");
+    }
+    if (hasSequencerState) {
+        reasons.push("sequencer-in-progress");
+    }
+    const available = reasons.length === 0;
+    return {
+        status: available ? "available" : "unavailable",
+        checkedRemoteAt,
+        gitStatus: status,
+        canAutoRebase: available,
+        canAutoMerge: available,
+        reasons,
+        ahead: status.ahead,
+        behind: status.behind,
+        upstream: status.upstream,
+        isClean: status.isClean,
+        hasSequencerState,
+    };
+}
+async function hasGitSequencerState(projectPath) {
+    const gitStatePaths = [
+        "MERGE_HEAD",
+        "CHERRY_PICK_HEAD",
+        "REVERT_HEAD",
+        "rebase-merge",
+        "rebase-apply",
+        "sequencer",
+    ];
+    const checks = await Promise.all(gitStatePaths.map((gitPath) => gitPathExists(projectPath, gitPath)));
+    return checks.some(Boolean);
+}
+async function gitPathExists(projectPath, gitPath) {
+    try {
+        const { stdout } = await runGit(projectPath, [
+            "rev-parse",
+            "--git-path",
+            gitPath,
+        ]);
+        const resolvedPath = stdout.trim();
+        if (!resolvedPath) {
+            return false;
+        }
+        await stat(resolve(projectPath, resolvedPath));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function getRecordedFetchAt(projectPath) {
+    try {
+        const { stdout } = await runGit(projectPath, [
+            "rev-parse",
+            "--git-path",
+            "FETCH_HEAD",
+        ]);
+        const fetchHeadPath = stdout.trim();
+        if (!fetchHeadPath) {
+            return null;
+        }
+        const fetchHeadStat = await stat(resolve(projectPath, fetchHeadPath));
+        if (!fetchHeadStat.isFile() || !Number.isFinite(fetchHeadStat.mtimeMs)) {
+            return null;
+        }
+        return fetchHeadStat.mtime.toISOString();
+    }
+    catch {
+        return null;
+    }
+}
+function latestIsoTimestamp(first, second) {
+    if (!first)
+        return second;
+    if (!second)
+        return first;
+    const firstTime = Date.parse(first);
+    const secondTime = Date.parse(second);
+    if (!Number.isFinite(firstTime))
+        return second;
+    if (!Number.isFinite(secondTime))
+        return first;
+    return secondTime > firstTime ? second : first;
+}
+function getGitErrorDetail(err) {
+    if (!err || typeof err !== "object") {
+        return undefined;
+    }
+    const gitError = err;
+    const detail = gitError.stderr || gitError.stdout || gitError.message;
+    return detail?.trim().slice(0, 1200) || undefined;
+}
+async function hasGitRemote(projectPath, remoteName) {
+    try {
+        await runGit(projectPath, ["remote", "get-url", remoteName]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 function isNotGitRepoError(err) {
     if (err && typeof err === "object") {
         const e = err;
-        if (e.code === 128)
-            return true;
         if (typeof e.stderr === "string" &&
             e.stderr.includes("not a git repository"))
             return true;
     }
     return false;
 }
+function isPushRejectedError(err) {
+    if (!err || typeof err !== "object") {
+        return false;
+    }
+    const gitError = err;
+    const output = `${gitError.stderr ?? ""}\n${gitError.stdout ?? ""}`;
+    return (output.includes("[rejected]") ||
+        output.includes("non-fast-forward") ||
+        output.includes("fetch first"));
+}
+function isPushAlreadyUpToDateOutput(result) {
+    return `${result.stdout}\n${result.stderr}`.includes("Everything up-to-date");
+}
 /** Parse `git diff --numstat` output into a map of path → {added, deleted} */
 function parseNumstat(output) {
     const map = new Map();
@@ -173,6 +617,114 @@ function parseNumstat(output) {
     }
     return map;
 }
+function isValidUntrackedFolderPath(path) {
+    if (!path.endsWith("/") || path.includes("\0")) {
+        return false;
+    }
+    if (path.startsWith("/") || /^[A-Za-z]:/.test(path)) {
+        return false;
+    }
+    const segments = path.slice(0, -1).split("/");
+    return (segments.length > 0 &&
+        segments.every((segment) => segment !== "" && segment !== ".."));
+}
+async function getUntrackedFolderInfo(projectPath, folderPath) {
+    const { files, truncated } = await collectUntrackedFolderFiles(projectPath, folderPath, UNTRACKED_FOLDER_FILE_LIMIT);
+    files.sort((a, b) => a.localeCompare(b));
+    return {
+        path: folderPath,
+        files,
+        truncated,
+        limit: UNTRACKED_FOLDER_FILE_LIMIT,
+    };
+}
+async function collectUntrackedFolderFiles(projectPath, folderPath, limit) {
+    return new Promise((resolvePromise, rejectPromise) => {
+        const child = spawn("git", [
+            "-C",
+            projectPath,
+            ...GIT_DECODE_PATHS_ARGS,
+            "status",
+            "--porcelain=v2",
+            "--untracked-files=all",
+            "--",
+            folderPath,
+        ]);
+        const files = [];
+        let stdoutRemainder = "";
+        let stderr = "";
+        let truncated = false;
+        let settled = false;
+        let stdoutBytes = 0;
+        let timeout;
+        const settle = (resolve, value) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
+            if (resolve) {
+                resolvePromise(value);
+            }
+            else {
+                rejectPromise(value);
+            }
+        };
+        const stopAsTruncated = () => {
+            if (truncated)
+                return;
+            truncated = true;
+            child.kill("SIGTERM");
+        };
+        const readStatusLine = (line) => {
+            if (!line.startsWith("? "))
+                return;
+            const path = line.slice(2);
+            if (!path.startsWith(folderPath) || path.endsWith("/"))
+                return;
+            if (files.length >= limit) {
+                stopAsTruncated();
+                return;
+            }
+            files.push(path);
+            if (files.length >= limit) {
+                stopAsTruncated();
+            }
+        };
+        timeout = setTimeout(stopAsTruncated, 10_000);
+        child.stdout.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => {
+            stdoutBytes += Buffer.byteLength(chunk);
+            stdoutRemainder += chunk;
+            const lines = stdoutRemainder.split("\n");
+            stdoutRemainder = lines.pop() ?? "";
+            for (const line of lines) {
+                readStatusLine(line);
+            }
+            if (stdoutBytes > 1024 * 1024) {
+                stopAsTruncated();
+            }
+        });
+        child.stderr.setEncoding("utf8");
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk;
+        });
+        child.on("error", (err) => {
+            settle(false, err);
+        });
+        child.on("close", (code) => {
+            if (stdoutRemainder) {
+                readStatusLine(stdoutRemainder);
+            }
+            if (code === 0 || truncated) {
+                settle(true, { files, truncated });
+                return;
+            }
+            const err = new Error(stderr.trim() || `git exited with code ${code}`);
+            Object.assign(err, { stderr });
+            settle(false, err);
+        });
+    });
+}
 /** Status letter from the XY field for a given position */
 function statusChar(xy, index) {
     if (!xy)
@@ -180,21 +732,45 @@ function statusChar(xy, index) {
     const ch = xy[index];
     return ch && ch !== "." ? ch : null;
 }
-async function getGitStatus(projectPath) {
-    // Run all three commands in parallel
-    const [statusResult, numstatUnstaged, numstatStaged] = await Promise.all([
-        runGit(projectPath, ["status", "--porcelain=v2", "--branch"]),
-        runGit(projectPath, ["diff", "--numstat"]).catch(() => ({
+async function getGitStatus(projectPath, checkedRemoteAt) {
+    // Run local read-only commands in parallel.
+    const [statusResult, numstatUnstaged, numstatStaged, logResult] = await Promise.all([
+        runGit(projectPath, [
+            ...GIT_DECODE_PATHS_ARGS,
+            "status",
+            "--porcelain=v2",
+            "--branch",
+        ]),
+        runGit(projectPath, [
+            ...GIT_DECODE_PATHS_ARGS,
+            "diff",
+            "--numstat",
+        ]).catch(() => ({
             stdout: "",
             stderr: "",
         })),
-        runGit(projectPath, ["diff", "--cached", "--numstat"]).catch(() => ({
+        runGit(projectPath, [
+            ...GIT_DECODE_PATHS_ARGS,
+            "diff",
+            "--cached",
+            "--numstat",
+        ]).catch(() => ({
+            stdout: "",
+            stderr: "",
+        })),
+        runGit(projectPath, [
+            "log",
+            "-n",
+            "5",
+            "--format=%H%x1f%h%x1f%an%x1f%aI%x1f%s%x1e",
+        ]).catch(() => ({
             stdout: "",
             stderr: "",
         })),
     ]);
     const unstagedStats = parseNumstat(numstatUnstaged.stdout);
     const stagedStats = parseNumstat(numstatStaged.stdout);
+    const recentCommits = parseRecentCommits(logResult.stdout);
     let branch = null;
     let upstream = null;
     let ahead = 0;
@@ -279,18 +855,17 @@ async function getGitStatus(projectPath) {
                 });
             }
         }
-        // Untracked: "? path" (skip directories — they end with /)
+        // Untracked: "? path". Git reports a whole untracked directory as
+        // "path/" until the caller explicitly asks for --untracked-files=all.
         else if (line.startsWith("? ")) {
             const path = line.slice(2);
-            if (!path.endsWith("/")) {
-                files.push({
-                    path,
-                    status: "?",
-                    staged: false,
-                    linesAdded: null,
-                    linesDeleted: null,
-                });
-            }
+            files.push({
+                path,
+                status: "?",
+                staged: false,
+                linesAdded: null,
+                linesDeleted: null,
+            });
         }
         // Unmerged: "u XY sub m1 m2 m3 mW h1 h2 h3 path"
         else if (line.startsWith("u ")) {
@@ -313,6 +888,29 @@ async function getGitStatus(projectPath) {
         behind,
         isClean: files.length === 0,
         files,
+        recentCommits,
+        checkedRemoteAt,
     };
 }
+function parseRecentCommits(output) {
+    const commits = [];
+    for (const rawRecord of output.split("\x1e")) {
+        const record = rawRecord.replace(/^\n/, "").replace(/\n$/, "");
+        if (!record)
+            continue;
+        const [hash, shortHash, authorName, authorDate, ...subjectParts] = record.split("\x1f");
+        const subject = subjectParts.join("\x1f");
+        if (!hash || !shortHash || !authorName || !authorDate) {
+            continue;
+        }
+        commits.push({
+            hash,
+            shortHash,
+            authorName,
+            authorDate,
+            subject,
+        });
+    }
+    return commits;
+}
 //# sourceMappingURL=git-status.js.map