tarsk 0.4.4 → 0.4.6

package/dist/features/git/git.utils.js

@@ -1,1040 +0,0 @@
-import { spawnProcess } from "../../core/utils.js";
-import { existsSync, readFileSync, statSync } from "fs";
-import { isAbsolute, normalize, resolve, join } from "path";
-import { getDataDir } from "../../core/paths.js";
-import { getModelsCatalog } from "../models/models-catalog.js";
-import { completeSimple, getModel, } from "@mariozechner/pi-ai";
-const PROVIDER_NAME_TO_PI = {
-    anthropic: "anthropic",
-    openai: "openai",
-    google: "google",
-    groq: "groq",
-    cerebras: "cerebras",
-    xai: "xai",
-    openrouter: "openrouter",
-    "github copilot": "github-copilot",
-    minimax: "minimax",
-    "kimi coding plan": "kimi-coding",
-    "hugging face": "huggingface",
-    codex: "openai-codex",
-    mistral: "mistral",
-};
-export const DEFAULT_MODEL_MAP = {
-    Anthropic: "claude-3-5-sonnet-20241022",
-    OpenAI: "gpt-4o-mini",
-    OpenRouter: "anthropic/claude-3.5-sonnet",
-    Groq: "llama-3.3-70b-versatile",
-    DeepSeek: "deepseek-chat",
-};
-export function resolveModelForGit(providerName, modelId, apiUrl) {
-    const piProvider = PROVIDER_NAME_TO_PI[providerName.toLowerCase()];
-    if (piProvider) {
-        try {
-            return getModel(piProvider, modelId);
-        }
-        catch {
-            // fall through to custom model
-        }
-    }
-    if (!apiUrl)
-        throw new Error(`No API URL configured for provider: ${providerName}`);
-    const apiType = apiUrl.includes("/anthropic/") || apiUrl.includes("api.anthropic.com")
-        ? "anthropic-messages"
-        : "openai-completions";
-    return {
-        id: modelId,
-        name: modelId,
-        api: apiType,
-        provider: providerName.toLowerCase(),
-        baseUrl: apiUrl,
-        reasoning: false,
-        input: ["text"],
-        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-        contextWindow: 128000,
-        maxTokens: 16384,
-    };
-}
-async function getAllProviders() {
-    const catalog = await getModelsCatalog();
-    if (!catalog)
-        return [];
-    return Object.values(catalog);
-}
-async function findProviderByName(name) {
-    const providers = await getAllProviders();
-    return providers.find((p) => p.name.toLowerCase() === name.toLowerCase()) ?? null;
-}
-async function overlayCatalogApi(prov) {
-    // The catalog already has the API info, so just return as-is
-    return prov;
-}
-export async function resolveProviderAndKey(metadataProviderKeys, preferredProvider) {
-    if (preferredProvider) {
-        const prov = await findProviderByName(preferredProvider);
-        if (prov) {
-            const envKey = prov.env.length > 0 ? prov.env[0] : undefined;
-            // Try both exact name match and case-insensitive match for metadata keys
-            const key = envKey && process.env[envKey]
-                ? process.env[envKey]
-                : (metadataProviderKeys[prov.name] ??
-                    (() => {
-                        const foundKey = Object.keys(metadataProviderKeys).find((k) => k.toLowerCase() === prov.name.toLowerCase());
-                        return foundKey ? metadataProviderKeys[foundKey] : undefined;
-                    })());
-            if (key)
-                return { provider: await overlayCatalogApi(prov), apiKey: key };
-        }
-    }
-    const providerPriority = ["Anthropic", "OpenAI", "OpenRouter", "Groq", "DeepSeek"];
-    for (const name of providerPriority) {
-        const prov = await findProviderByName(name);
-        if (prov && prov.env.length > 0) {
-            const envKey = process.env[prov.env[0]];
-            if (envKey)
-                return { provider: await overlayCatalogApi(prov), apiKey: envKey };
-        }
-    }
-    for (const name of providerPriority) {
-        const prov = await findProviderByName(name);
-        if (prov && metadataProviderKeys[prov.name]) {
-            return { provider: await overlayCatalogApi(prov), apiKey: metadataProviderKeys[prov.name] };
-        }
-    }
-    const allProviders = await getAllProviders();
-    for (const prov of allProviders) {
-        if (prov.api && prov.env.length > 0) {
-            const envKey = process.env[prov.env[0]];
-            if (envKey)
-                return { provider: await overlayCatalogApi(prov), apiKey: envKey };
-            const metadataKey = Object.keys(metadataProviderKeys).find((k) => k.toLowerCase() === prov.name.toLowerCase());
-            if (metadataKey)
-                return {
-                    provider: await overlayCatalogApi(prov),
-                    apiKey: metadataProviderKeys[metadataKey],
-                };
-        }
-    }
-    return null;
-}
-export async function generatePRInfoWithAI(commitLog, detailedCommits, diff, currentBranch, baseBranch, metadataManager, model, provider) {
-    // Build the prompt content - prefer commits for PR generation, fall back to diff
-    let promptContent;
-    if (commitLog.trim()) {
-        // We have commits between branches - use those for PR info
-        promptContent = `Based on the following commits in branch "${currentBranch}" compared to "${baseBranch}", generate a pull request title and description.
-
-Commit log:
-${commitLog}
-
-Detailed commit messages:
-${detailedCommits || "(no details available)"}
-
-${diff.trim() ? `\nAdditionally, there are uncommitted changes:\n${diff.length > 1500 ? diff.substring(0, 1500) + "\n...(truncated)" : diff}` : ""}`;
-    }
-    else {
-        // No commits between branches - use just the diff
-        const truncatedDiff = diff.length > 3000 ? diff.substring(0, 3000) + "\n...(truncated)" : diff;
-        promptContent = `Based on the following git diff, generate a pull request title and description.
-
-Git diff:
-${truncatedDiff}`;
-    }
-    const prompt = `${promptContent}
-
-Follow these guidelines:
-- Title: Concise, descriptive, under 72 characters
-- Description: Clear explanation of changes, why they were made, and any relevant context
-- Use markdown formatting for the description (bullet points, headers, etc.)
-- Be professional and clear
-- If multiple changes, group them logically in the description
-
-Generate the response in this exact format:
-TITLE: <title here>
-DESCRIPTION: <description here>`;
-    try {
-        const providerKeys = await metadataManager.getProviderKeys();
-        const resolved = await resolveProviderAndKey(providerKeys, provider);
-        if (!resolved?.provider?.api) {
-            const errorMsg = provider
-                ? `AI provider "${provider}" is specified but no API key is configured. Please add the API key in settings.`
-                : `No AI provider configured. Please configure a provider in settings.`;
-            console.log(`[pr-generation] ${errorMsg}`);
-            return { title: "Update", description: "" };
-        }
-        let selectedModel = model;
-        if (selectedModel) {
-            selectedModel = selectedModel.replace(`${resolved.provider.name.toLowerCase()}/`, "");
-        }
-        else {
-            selectedModel = DEFAULT_MODEL_MAP[resolved.provider.name] || "default";
-        }
-        const resolvedModel = resolveModelForGit(resolved.provider.name, selectedModel, resolved.provider.api);
-        console.log(`[pr-generation] Using model: ${resolvedModel.name} provider: ${resolved.provider.name}. key: ${resolved.apiKey ? "exists" : "undefined"} prompt length: ${prompt.length}`);
-        const response = await completeSimple(resolvedModel, {
-            messages: [{ role: "user", content: prompt, timestamp: Date.now() }],
-        }, { apiKey: resolved.apiKey });
-        const prInfo = response.content
-            .filter((b) => b.type === "text")
-            .map((b) => b.text)
-            .join("")
-            .trim();
-        const titleMatch = prInfo.match(/TITLE:\s*(.+?)(?:\nDESCRIPTION:|$)/s);
-        const descriptionMatch = prInfo.match(/DESCRIPTION:\s*(.+?)$/s);
-        const title = titleMatch ? titleMatch[1].trim() : "Update";
-        const description = descriptionMatch ? descriptionMatch[1].trim() : "";
-        return { title, description };
-    }
-    catch (error) {
-        console.log(`[pr-generation] Error in generatePRInfoWithAI: ${error instanceof Error ? error.message : String(error)}`);
-        return { title: "Update", description: "" };
-    }
-}
-export async function generateCommitMessageWithAI(diff, metadataManager, model, provider) {
-    const truncatedDiff = diff.length > 3000 ? diff.substring(0, 3000) + "\n...(truncated)" : diff;
-    const prompt = `Based on the following git diff, generate a concise, conventional commit message. Follow these guidelines:
-- Use conventional commit format: type(scope): description
-- Types: feat, fix, docs, style, refactor, test, chore
-- Keep it under 72 characters
-- Be specific and descriptive
-- Focus on what changed and why
-
-Git diff:
-${truncatedDiff}
-
-Generate only the commit message, nothing else:`;
-    try {
-        const providerKeys = await metadataManager.getProviderKeys();
-        const resolved = await resolveProviderAndKey(providerKeys, provider);
-        if (!resolved?.provider?.api) {
-            const errorMsg = provider
-                ? `AI provider "${provider}" is specified but no API key is configured. Please add the API key in settings.`
-                : `No AI provider configured. Please configure a provider in settings.`;
-            process.stdout.write(`[generate-commit-message] ${errorMsg}\n`);
-            return `AI Error: ${errorMsg}`;
-        }
-        let selectedModel = model;
-        if (selectedModel) {
-            selectedModel = selectedModel.replace(`${resolved.provider.name.toLowerCase()}/`, "");
-        }
-        else {
-            selectedModel = DEFAULT_MODEL_MAP[resolved.provider.name] || "default";
-        }
-        const resolvedModel = resolveModelForGit(resolved.provider.name, selectedModel, resolved.provider.api);
-        console.log(`[generate-commit-message] Using model: ${resolvedModel.name} provider: ${resolved.provider.name}. key: ${resolved.apiKey ? "exists" : "undefined"} prompt: ${prompt}`);
-        const response = await completeSimple(resolvedModel, {
-            messages: [{ role: "user", content: prompt, timestamp: Date.now() }],
-        }, { apiKey: resolved.apiKey });
-        let commitMessage = response.content
-            .filter((b) => b.type === "text")
-            .map((b) => b.text)
-            .join("")
-            .trim();
-        commitMessage = commitMessage.replace(/^["']|["']$/g, "").trim();
-        if (!commitMessage) {
-            console.log(`[generate-commit-message] AI returned empty commit message, using fallback`, response);
-            process.stdout.write("[generate-commit-message] AI returned empty commit message, using fallback\n");
-            return "Update files";
-        }
-        return commitMessage;
-    }
-    catch (error) {
-        const errorMsg = error instanceof Error ? error.message : String(error);
-        process.stdout.write(`[generate-commit-message] AI generation failed: ${errorMsg}\n`);
-        return `AI Error: Failed to generate commit message: ${errorMsg}`;
-    }
-}
-/** Resolve thread path: if absolute use as-is (normalized), else resolve against data dir. */
-export function resolveThreadPath(repoPath) {
-    const base = isAbsolute(repoPath) ? repoPath : resolve(getDataDir(), repoPath);
-    return normalize(base);
-}
-/** Get git repo root for a path (directory or subdir of repo). Throws if not a git repo. */
-export function getGitRoot(cwd) {
-    return new Promise((resolveRoot, reject) => {
-        const proc = spawnProcess("git", ["rev-parse", "--show-toplevel"], { cwd });
-        let out = "";
-        let err = "";
-        if (proc.stdout) {
-            proc.stdout.on("data", (d) => {
-                out += d.toString();
-            });
-        }
-        if (proc.stderr) {
-            proc.stderr.on("data", (d) => {
-                err += d.toString();
-            });
-        }
-        proc.on("close", (code) => {
-            if (code === 0) {
-                resolveRoot(out.trim());
-            }
-            else {
-                reject(new Error(err.trim() || "Not a git repository"));
-            }
-        });
-        proc.on("error", reject);
-    });
-}
-/** Get current git branch */
-export function getCurrentBranch(gitRoot) {
-    return new Promise((resolve) => {
-        const proc = spawnProcess("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: gitRoot });
-        let out = "";
-        if (proc.stdout) {
-            proc.stdout.on("data", (d) => {
-                out += d.toString();
-            });
-        }
-        proc.on("close", () => {
-            resolve(out.trim());
-        });
-        proc.on("error", () => resolve(""));
-    });
-}
-/** Get git diff for staged and unstaged changes */
-export async function getGitDiff(gitRoot) {
-    return new Promise((resolveDiff, reject) => {
-        const runUnstagedDiff = () => {
-            const proc2 = spawnProcess("git", ["diff"], { cwd: gitRoot });
-            let out2 = "";
-            if (proc2.stdout) {
-                proc2.stdout.on("data", (d) => {
-                    out2 += d.toString();
-                });
-            }
-            proc2.on("close", (code) => {
-                resolveDiff(code === 0 ? out2 : "");
-            });
-            proc2.on("error", reject);
-        };
-        const proc = spawnProcess("git", ["diff", "--cached"], { cwd: gitRoot });
-        let out = "";
-        let err = "";
-        if (proc.stdout) {
-            proc.stdout.on("data", (d) => {
-                out += d.toString();
-            });
-        }
-        if (proc.stderr) {
-            proc.stderr.on("data", (d) => {
-                err += d.toString();
-            });
-        }
-        proc.on("close", (code) => {
-            if (code === 0) {
-                if (!out.trim()) {
-                    runUnstagedDiff();
-                }
-                else {
-                    resolveDiff(out);
-                }
-            }
-            else {
-                // No commits yet (HEAD missing) or similar: use working tree diff
-                const noHead = /HEAD|revision|unknown revision/i.test(err);
-                if (noHead) {
-                    runUnstagedDiff();
-                }
-                else {
-                    reject(new Error(err || "Failed to get git diff"));
-                }
-            }
-        });
-        proc.on("error", reject);
-    });
-}
-/** Get diff for untracked files */
-export async function getUntrackedFilesDiff(gitRoot) {
-    const statusOut = await new Promise((resolveStatus) => {
-        const proc = spawnProcess("git", ["status", "--porcelain", "--untracked-files=all"], {
-            cwd: gitRoot,
-        });
-        let out = "";
-        if (proc.stdout) {
-            proc.stdout.on("data", (d) => {
-                out += d.toString();
-            });
-        }
-        proc.on("close", () => resolveStatus(out));
-        proc.on("error", () => resolveStatus(""));
-    });
-    const lines = statusOut
-        .trim()
-        .split("\n")
-        .filter((l) => l.length > 0);
-    const untrackedPaths = [];
-    for (const line of lines) {
-        const code = line.slice(0, 2);
-        const pathPart = line.slice(3).trim();
-        if (code === "??") {
-            untrackedPaths.push(pathPart);
-        }
-    }
-    if (untrackedPaths.length === 0)
-        return "";
-    const parts = [];
-    const maxFileSize = 100_000;
-    for (const relPath of untrackedPaths) {
-        const fullPath = join(gitRoot, relPath);
-        if (!existsSync(fullPath))
-            continue;
-        try {
-            if (statSync(fullPath).isDirectory())
-                continue;
-            const content = readFileSync(fullPath, "utf-8");
-            const safeContent = content.length > maxFileSize ? content.slice(0, maxFileSize) + "\n...(truncated)" : content;
-            const linesForDiff = safeContent
-                .split(/\r?\n/)
-                .map((l) => `+${l}`)
-                .join("\n");
-            parts.push(`diff --git a/${relPath} b/${relPath}\nnew file mode 100644\n--- /dev/null\n+++ b/${relPath}\n${linesForDiff}`);
-        }
-        catch {
-            parts.push(`diff --git a/${relPath} b/${relPath}\nnew file mode 100644\n(Binary or unreadable file: ${relPath})`);
-        }
-    }
-    return parts.join("\n");
-}
-/** Get git status output */
-export function getGitStatus(gitRoot) {
-    return new Promise((resolve) => {
-        const proc = spawnProcess("git", ["status", "--porcelain", "--untracked-files=all"], {
-            cwd: gitRoot,
-        });
-        let out = "";
-        if (proc.stdout) {
-            proc.stdout.on("data", (d) => {
-                out += d.toString();
-            });
-        }
-        proc.on("close", () => resolve(out));
-        proc.on("error", () => resolve(""));
-    });
-}
-/** Check if there are unpushed commits */
-export function hasUnpushedCommits(gitRoot, currentBranch) {
-    return new Promise((resolve) => {
-        const proc = spawnProcess("git", ["log", `origin/${currentBranch}..HEAD`, "--oneline"], {
-            cwd: gitRoot,
-        });
-        let out = "";
-        if (proc.stdout) {
-            proc.stdout.on("data", (d) => {
-                out += d.toString();
-            });
-        }
-        proc.on("close", () => {
-            resolve(out.trim().length > 0);
-        });
-        proc.on("error", () => resolve(false));
-    });
-}
-/** Check if current branch has commits not yet in the default branch (pushed or not) */
-export function hasCommitsAheadOfDefault(gitRoot, defaultBranch) {
-    return new Promise((resolve) => {
-        const proc = spawnProcess("git", ["rev-list", "--count", `origin/${defaultBranch}..HEAD`], {
-            cwd: gitRoot,
-        });
-        let out = "";
-        if (proc.stdout) {
-            proc.stdout.on("data", (d) => {
-                out += d.toString();
-            });
-        }
-        proc.on("close", (code) => {
-            if (code === 0) {
-                resolve(parseInt(out.trim(), 10) > 0);
-            }
-            else {
-                resolve(false);
-            }
-        });
-        proc.on("error", () => resolve(false));
-    });
-}
-/** Get remote origin URL */
-export function getRemoteOrigin(gitRoot) {
-    return new Promise((resolve) => {
-        const proc = spawnProcess("git", ["remote", "get-url", "origin"], { cwd: gitRoot });
-        let out = "";
-        if (proc.stdout) {
-            proc.stdout.on("data", (d) => {
-                out += d.toString();
-            });
-        }
-        proc.on("close", (code) => {
-            if (code === 0) {
-                resolve(out.trim());
-            }
-            else {
-                resolve(""); // No origin remote
-            }
-        });
-        proc.on("error", () => resolve(""));
-    });
-}
-/** Get the hash of the origin branch head */
-export function getOriginBranchHash(gitRoot, branch) {
-    return new Promise((resolve) => {
-        const proc = spawnProcess("git", ["show-ref", "--heads", "-s", `origin/${branch}`], {
-            cwd: gitRoot,
-        });
-        let out = "";
-        if (proc.stdout) {
-            proc.stdout.on("data", (d) => {
-                out += d.toString();
-            });
-        }
-        if (proc.stderr) {
-            proc.stderr.on("data", () => {
-                // Ignore stderr
-            });
-        }
-        proc.on("close", (code) => {
-            if (code === 0 && out.trim()) {
-                resolve(out.trim());
-            }
-            else {
-                resolve(null);
-            }
-        });
-        proc.on("error", () => resolve(null));
-    });
-}
-/** Get the merge-base hash between origin branch and current branch */
-export function getMergeBaseHash(gitRoot, originBranch, currentBranch) {
-    return new Promise((resolve) => {
-        const proc = spawnProcess("git", ["merge-base", `origin/${originBranch}`, currentBranch], {
-            cwd: gitRoot,
-        });
-        let out = "";
-        if (proc.stdout) {
-            proc.stdout.on("data", (d) => {
-                out += d.toString();
-            });
-        }
-        if (proc.stderr) {
-            proc.stderr.on("data", () => {
-                // Ignore stderr
-            });
-        }
-        proc.on("close", (code) => {
-            if (code === 0 && out.trim()) {
-                resolve(out.trim());
-            }
-            else {
-                resolve(null);
-            }
-        });
-        proc.on("error", () => resolve(null));
-    });
-}
-/** Check if current branch is behind origin branch */
-export async function isBranchBehind(gitRoot, branch) {
-    const originHash = await getOriginBranchHash(gitRoot, branch);
-    const mergeBaseHash = await getMergeBaseHash(gitRoot, branch, branch);
-    // If either hash is null, we can't determine the status
-    if (!originHash || !mergeBaseHash) {
-        return false;
-    }
-    // If hashes are different, the branch is behind
-    return originHash !== mergeBaseHash;
-}
-/** Get detailed git sync status (Behind, Ahead, Diverged, Up to date) */
-export async function getGitSyncStatus(gitRoot, branch) {
-    console.log(`[git-status] Checking sync status for branch: ${branch}`);
-    // Fetch to update remote tracking information
-    console.log(`[git-status] Fetching from origin...`);
-    await new Promise((resolve) => {
-        const fetchProc = spawnProcess("git", ["fetch", "origin"], { cwd: gitRoot });
-        fetchProc.on("close", () => {
-            console.log(`[git-status] ✓ Fetch completed`);
-            resolve();
-        });
-        fetchProc.on("error", () => {
-            console.log(`[git-status] Fetch error (continuing anyway)`);
-            resolve();
-        });
-    });
-    // Check if branch is behind the default branch
-    console.log(`[git-status] Finding default branch...`);
-    const defaultBranch = await findDefaultBranch(gitRoot);
-    console.log(`[git-status] Default branch: ${defaultBranch}`);
-    if (defaultBranch && defaultBranch !== branch) {
-        console.log(`[git-status] Checking if ${branch} is behind ${defaultBranch}...`);
-        // Count commits in default branch that are not in current branch
-        const isBehindDefault = await new Promise((resolve) => {
-            const proc = spawnProcess("git", ["rev-list", "--count", `${branch}..origin/${defaultBranch}`], { cwd: gitRoot });
-            let out = "";
-            if (proc.stdout) {
-                proc.stdout.on("data", (d) => {
-                    out += d.toString();
-                });
-            }
-            proc.on("close", () => {
-                const count = parseInt(out.trim(), 10);
-                console.log(`[git-status] Commits in ${defaultBranch} but not in ${branch}: ${count}`);
-                resolve(count > 0);
-            });
-            proc.on("error", () => {
-                console.log(`[git-status] Error checking commits (assuming not behind)`);
-                resolve(false);
-            });
-        });
-        if (isBehindDefault) {
-            console.log(`[git-status] ✓ Branch IS behind default branch`);
-            return "Behind";
-        }
-        console.log(`[git-status] Branch is NOT behind default branch`);
-    }
-    else {
-        console.log(`[git-status] Skipping default branch check (same branch or no default found)`);
-    }
-    // Check git status against remote tracking branch
-    console.log(`[git-status] Checking status against remote tracking branch...`);
-    return new Promise((resolve) => {
-        const statusProc = spawnProcess("git", ["status", "-sb"], { cwd: gitRoot });
-        let statusOut = "";
-        let statusErr = "";
-        if (statusProc.stdout) {
-            statusProc.stdout.on("data", (d) => {
-                statusOut += d.toString();
-            });
-        }
-        if (statusProc.stderr) {
-            statusProc.stderr.on("data", (d) => {
-                statusErr += d.toString();
-            });
-        }
-        statusProc.on("close", () => {
-            const output = statusOut + statusErr;
-            console.log(`[git-status] git status -sb output: ${output.trim()}`);
-            // Validate that we're checking the right branch
-            if (!output.includes(branch)) {
-                console.log(`[git-status] Branch name not found in status output, returning 'Up to date'`);
-                resolve("Up to date");
-                return;
-            }
-            // Check for each status pattern based on git status output
-            if (output.includes("ahead") && output.includes("behind")) {
-                console.log(`[git-status] ✓ Status: Diverged`);
-                resolve("Diverged");
-            }
-            else if (output.includes("behind")) {
-                console.log(`[git-status] ✓ Status: Behind`);
-                resolve("Behind");
-            }
-            else if (output.includes("ahead")) {
-                console.log(`[git-status] ✓ Status: Ahead`);
-                resolve("Ahead");
-            }
-            else if (output.includes("#") && !output.includes("ahead") && !output.includes("behind")) {
-                console.log(`[git-status] ✓ Status: Up to date`);
-                resolve("Up to date");
-            }
-            else {
-                console.log(`[git-status] ✓ Status: Up to date (default)`);
-                resolve("Up to date");
-            }
-        });
-        statusProc.on("error", () => {
-            console.log(`[git-status] Error getting status, defaulting to 'Up to date'`);
-            resolve("Up to date");
-        });
-    });
-}
-/** Check if remote branch exists */
-export async function hasRemoteBranch(gitRoot, branch) {
-    return new Promise((resolve) => {
-        const proc = spawnProcess("git", ["rev-parse", "--verify", `origin/${branch}`], {
-            cwd: gitRoot,
-        });
-        proc.on("close", (code) => {
-            resolve(code === 0);
-        });
-        proc.on("error", () => {
-            resolve(false);
-        });
-    });
-}
-/** Get default branch from origin/HEAD */
-export function getDefaultBranch(gitRoot) {
-    return new Promise((resolve) => {
-        const proc = spawnProcess("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], {
-            cwd: gitRoot,
-        });
-        let out = "";
-        if (proc.stdout) {
-            proc.stdout.on("data", (d) => {
-                out += d.toString();
-            });
-        }
-        proc.on("close", (code) => {
-            if (code === 0 && out.trim()) {
-                // Output is like: refs/remotes/origin/main
-                const match = out.trim().match(/refs\/remotes\/origin\/(.+)/);
-                resolve(match ? match[1] : null);
-            }
-            else {
-                resolve(null);
-            }
-        });
-        proc.on("error", () => resolve(null));
-    });
-}
-/** Find default branch by checking common candidates */
-export async function findDefaultBranch(gitRoot) {
-    const candidates = ["main", "master", "develop", "staging"];
-    for (const branch of candidates) {
-        const exists = await new Promise((resolve) => {
-            const proc = spawnProcess("git", ["rev-parse", "--verify", `origin/${branch}`], {
-                cwd: gitRoot,
-            });
-            proc.on("close", (code) => resolve(code === 0));
-            proc.on("error", () => resolve(false));
-        });
-        if (exists)
-            return branch;
-    }
-    return null;
-}
-/** Get commit log between branches */
-export function getCommitLog(gitRoot, baseBranch, currentBranch) {
-    return new Promise((resolve) => {
-        const proc = spawnProcess("git", ["log", "--oneline", `${baseBranch}..${currentBranch}`], {
-            cwd: gitRoot,
-        });
-        let out = "";
-        if (proc.stdout) {
-            proc.stdout.on("data", (d) => {
-                out += d.toString();
-            });
-        }
-        proc.on("close", () => resolve(out.trim()));
-        proc.on("error", () => resolve(""));
-    });
-}
-/** Get detailed commit information */
-export async function getDetailedCommits(gitRoot, baseBranch, currentBranch) {
-    return new Promise((resolve) => {
-        // Get commit messages with body (subject + body, limited)
-        const proc = spawnProcess("git", ["log", `${baseBranch}..${currentBranch}`, "--format=%h %s%n%b%n---"], { cwd: gitRoot });
-        let out = "";
-        if (proc.stdout) {
-            proc.stdout.on("data", (d) => {
-                out += d.toString();
-            });
-        }
-        proc.on("close", () => {
-            // Truncate to avoid huge prompts
-            resolve(out.length > 2000 ? out.substring(0, 2000) + "\n...(more commits)" : out);
-        });
-        proc.on("error", () => resolve(""));
-    });
-}
-/** Get git log with limit */
-export function getGitLog(gitRoot, limit) {
-    return new Promise((resolve, reject) => {
-        const proc = spawnProcess("git", ["log", "--oneline", "-n", limit.toString(), "--format=%H|%s|%an|%ai"], { cwd: gitRoot });
-        let out = "";
-        let err = "";
-        if (proc.stdout) {
-            proc.stdout.on("data", (d) => {
-                out += d.toString();
-            });
-        }
-        if (proc.stderr) {
-            proc.stderr.on("data", (d) => {
-                err += d.toString();
-            });
-        }
-        proc.on("close", (code) => {
-            if (code === 0) {
-                const lines = out
-                    .trim()
-                    .split("\n")
-                    .filter((line) => line.length > 0);
-                const parsed = lines.map((line) => {
-                    const parts = line.split("|");
-                    return {
-                        hash: parts[0] || "",
-                        message: parts[1] || "",
-                        author: parts[2] || "",
-                        date: parts[3] || "",
-                    };
-                });
-                resolve(parsed);
-            }
-            else {
-                reject(new Error(err || "Failed to get git log"));
-            }
-        });
-        proc.on("error", reject);
-    });
-}
-/** Stage all changes */
-export function stageAllChanges(gitRoot) {
-    return new Promise((resolve, reject) => {
-        const proc = spawnProcess("git", ["add", "-A"], { cwd: gitRoot });
-        proc.on("close", (code) => {
-            if (code === 0)
-                resolve();
-            else
-                reject(new Error("Failed to stage changes"));
-        });
-        proc.on("error", reject);
-    });
-}
-/** Commit changes */
-export function commitChanges(gitRoot, message) {
-    return new Promise((resolve, reject) => {
-        const proc = spawnProcess("git", ["commit", "-m", message], { cwd: gitRoot });
-        proc.on("close", (code) => {
-            if (code === 0)
-                resolve();
-            else
-                reject(new Error("Failed to commit changes"));
-        });
-        proc.on("error", reject);
-    });
-}
-/** Push changes to origin */
-export function pushToOrigin(gitRoot, currentBranch) {
-    return new Promise((resolve, reject) => {
-        console.log(`[git-push] Executing: git push -u origin ${currentBranch}`);
-        const proc = spawnProcess("git", ["push", "-u", "origin", currentBranch], { cwd: gitRoot });
-        let err = "";
-        let _out = "";
-        if (proc.stdout) {
-            proc.stdout.on("data", (d) => {
-                _out += d.toString();
-                console.log(`[git-push] stdout: ${d.toString().trim()}`);
-            });
-        }
-        if (proc.stderr) {
-            proc.stderr.on("data", (d) => {
-                err += d.toString();
-                console.log(`[git-push] stderr: ${d.toString().trim()}`);
-            });
-        }
-        proc.on("close", (code) => {
-            console.log(`[git-push] git push exited with code: ${code}`);
-            if (code === 0) {
-                console.log(`[git-push] ✓ Push completed successfully`);
-                resolve();
-            }
-            else {
-                console.log(`[git-push] ✗ Push failed with error: ${err || "Unknown error"}`);
-                reject(new Error(err || "Failed to push changes"));
-            }
-        });
-        proc.on("error", (error) => {
-            console.log(`[git-push] ✗ Process error: ${error instanceof Error ? error.message : String(error)}`);
-            reject(error);
-        });
-    });
-}
-/** Fetch from origin */
-export function fetchFromOrigin(gitRoot) {
-    return new Promise((resolve, reject) => {
-        const proc = spawnProcess("git", ["fetch", "origin"], { cwd: gitRoot });
-        let err = "";
-        if (proc.stderr) {
-            proc.stderr.on("data", (d) => {
-                err += d.toString();
-            });
-        }
-        proc.on("close", (code) => {
-            if (code === 0)
-                resolve();
-            else
-                reject(new Error(err || "Failed to fetch from origin"));
-        });
-        proc.on("error", reject);
-    });
-}
-/** Pull from origin */
-export function pullFromOrigin(gitRoot) {
-    return new Promise((resolve, reject) => {
-        const proc = spawnProcess("git", ["pull"], { cwd: gitRoot });
-        let err = "";
-        if (proc.stderr) {
-            proc.stderr.on("data", (d) => {
-                err += d.toString();
-            });
-        }
-        proc.on("close", (code) => {
-            if (code === 0)
-                resolve();
-            else
-                reject(new Error(err || "Failed to pull from origin"));
-        });
-        proc.on("error", reject);
-    });
-}
-/** Stash changes */
-export function stashChanges(gitRoot) {
-    return new Promise((resolve, reject) => {
-        const proc = spawnProcess("git", ["stash"], { cwd: gitRoot });
-        let err = "";
-        if (proc.stderr) {
-            proc.stderr.on("data", (d) => {
-                err += d.toString();
-            });
-        }
-        proc.on("close", (code) => {
-            if (code === 0)
-                resolve();
-            else
-                reject(new Error(err || "Failed to stash changes"));
-        });
-        proc.on("error", reject);
-    });
-}
-/** Pop stashed changes */
-export function popStashedChanges(gitRoot) {
-    return new Promise((resolve, reject) => {
-        const proc = spawnProcess("git", ["stash", "pop"], { cwd: gitRoot });
-        let err = "";
-        if (proc.stderr) {
-            proc.stderr.on("data", (d) => {
-                err += d.toString();
-            });
-        }
-        proc.on("close", (code) => {
-            if (code === 0)
-                resolve();
-            else
-                reject(new Error(err || "Failed to pop stashed changes"));
-        });
-        proc.on("error", reject);
-    });
-}
-/** Create GitHub repository using gh CLI */
-export function createGitHubRepo(gitRoot, repoName, description, isPrivate) {
-    return new Promise((resolve, reject) => {
-        const args = ["repo", "create"];
-        if (repoName) {
-            args.push(repoName);
-        }
-        if (description) {
-            args.push("--description", description);
-        }
-        if (isPrivate) {
-            args.push("--private");
-        }
-        else {
-            args.push("--public");
-        }
-        args.push("--source", ".", "--push");
-        const proc = spawnProcess("gh", args, { cwd: gitRoot });
-        let out = "";
-        let err = "";
-        if (proc.stdout) {
-            proc.stdout.on("data", (d) => {
-                out += d.toString();
-            });
-        }
-        if (proc.stderr) {
-            proc.stderr.on("data", (d) => {
-                err += d.toString();
-            });
-        }
-        proc.on("close", (code) => {
-            if (code === 0) {
-                // Extract URL from output
-                const urlMatch = out.match(/https:\/\/[^\s]+/);
-                resolve(urlMatch ? urlMatch[0] : out.trim());
-            }
-            else {
-                reject(new Error(err || "Failed to create repository"));
-            }
-        });
-        proc.on("error", () => reject(new Error("GitHub CLI (gh) not found. Please install it to create repositories.")));
-    });
-}
-/** Create pull request using gh CLI */
-export function createPullRequest(gitRoot, title, description) {
-    return new Promise((resolve, reject) => {
-        const args = ["pr", "create", "--title", title ?? "", "--body", description ?? ""];
-        console.log(`[git-create-pr] Executing: gh ${args.join(" ")}`);
-        const proc = spawnProcess("gh", args, { cwd: gitRoot });
-        let out = "";
-        let err = "";
-        if (proc.stdout) {
-            proc.stdout.on("data", (d) => {
-                out += d.toString();
-                console.log(`[git-create-pr] stdout: ${d.toString().trim()}`);
-            });
-        }
-        if (proc.stderr) {
-            proc.stderr.on("data", (d) => {
-                err += d.toString();
-                console.log(`[git-create-pr] stderr: ${d.toString().trim()}`);
-            });
-        }
-        proc.on("close", (code) => {
-            console.log(`[git-create-pr] gh pr create exited with code: ${code}`);
-            if (code === 0) {
-                // Extract URL from output
-                const urlMatch = out.match(/https:\/\/[^\s]+/);
-                const prUrl = urlMatch ? urlMatch[0] : out.trim();
-                console.log(`[git-create-pr] ✓ PR URL extracted: ${prUrl}`);
-                resolve(prUrl);
-            }
-            else {
-                console.log(`[git-create-pr] ✗ gh pr create failed with error: ${err || "Unknown error"}`);
-                reject(new Error(err || "Failed to create PR"));
-            }
-        });
-        proc.on("error", (error) => {
-            console.log(`[git-create-pr] ✗ Process error: ${error instanceof Error ? error.message : String(error)}`);
-            reject(new Error("GitHub CLI (gh) not found. Please install it to create PRs."));
-        });
-    });
-}
-/** Check if there's an existing PR for the current branch */
-export function getPullRequestStatus(gitRoot) {
-    return new Promise((resolve, reject) => {
-        const args = ["pr", "view", "--json", "url,state"];
-        const proc = spawnProcess("gh", args, { cwd: gitRoot });
-        let out = "";
-        let err = "";
-        if (proc.stdout) {
-            proc.stdout.on("data", (d) => {
-                out += d.toString();
-            });
-        }
-        if (proc.stderr) {
-            proc.stderr.on("data", (d) => {
-                err += d.toString();
-            });
-        }
-        proc.on("close", (code) => {
-            if (code === 0) {
-                try {
-                    const prData = JSON.parse(out.trim());
-                    resolve({
-                        exists: true,
-                        url: prData.url,
-                        state: prData.state,
-                    });
-                }
-                catch {
-                    reject(new Error("Failed to parse PR data"));
-                }
-            }
-            else {
-                // Check if error indicates no PR exists
-                if (err.includes("no pull requests") || err.includes("not found")) {
-                    resolve({ exists: false });
-                }
-                else {
-                    reject(new Error(err || "Failed to check PR status"));
-                }
-            }
-        });
-        proc.on("error", () => reject(new Error("GitHub CLI (gh) not found. Please install it to check PR status.")));
-    });
-}
-//# sourceMappingURL=git.utils.js.map