@minionry/minion 0.7.36

package/dist/server/services/git/command.js

@@ -0,0 +1,68 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { spawn } from 'node:child_process';
+export function executeGitCommand(args, workingDir, options = {}) {
+    return new Promise((resolve) => {
+        const git = spawn('git', args, {
+            cwd: workingDir,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            env: options.env ? { ...process.env, ...options.env } : undefined,
+        });
+        let stdout = '';
+        let stderr = '';
+        let timedOut = false;
+        let overflowed = false;
+        const timer = options.timeoutMs
+            ? setTimeout(() => { timedOut = true; git.kill(); }, options.timeoutMs)
+            : null;
+        git.stdout?.on('data', (data) => {
+            stdout += data.toString();
+            if (options.maxOutputBytes && stdout.length > options.maxOutputBytes && !overflowed) {
+                overflowed = true;
+                git.kill();
+            }
+        });
+        git.stderr?.on('data', (data) => {
+            stderr += data.toString();
+        });
+        git.on('close', (code) => {
+            if (timer)
+                clearTimeout(timer);
+            if (timedOut) {
+                resolve({ stdout, stderr: `git ${args[0]} timed out after ${options.timeoutMs}ms`, exitCode: 1 });
+            }
+            else if (overflowed) {
+                resolve({ stdout, stderr: `git ${args[0]} output exceeded ${options.maxOutputBytes} bytes`, exitCode: 1 });
+            }
+            else {
+                resolve({ stdout, stderr, exitCode: code ?? 1 });
+            }
+        });
+        git.on('error', (err) => {
+            if (timer)
+                clearTimeout(timer);
+            resolve({ stdout: '', stderr: err.message, exitCode: 1 });
+        });
+    });
+}
+export function spawnCheck(bin, args) {
+    return new Promise((resolve) => {
+        const proc = spawn(bin, args, { stdio: ['ignore', 'pipe', 'pipe'] });
+        proc.on('close', (code) => resolve(code === 0));
+        proc.on('error', () => resolve(false));
+    });
+}
+export function spawnWithOutput(bin, args, cwd) {
+    return new Promise((resolve) => {
+        const proc = spawn(bin, args, { cwd, stdio: ['ignore', 'pipe', 'pipe'] });
+        let stdout = '';
+        let stderr = '';
+        proc.stdout?.on('data', (d) => { stdout += d.toString(); });
+        proc.stderr?.on('data', (d) => { stderr += d.toString(); });
+        proc.on('close', (code) => resolve({ stdout, stderr, exitCode: code ?? 1 }));
+        proc.on('error', (err) => resolve({ stdout: '', stderr: err.message, exitCode: 1 }));
+    });
+}
+export function gitErrorText(result, fallback) {
+    return result.stderr || result.stdout || fallback;
+}

package/dist/server/services/git/commit-message.js

@@ -0,0 +1,74 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { loadSkillPrompt } from '../plan/agent-loader.js';
+import { executeGitCommand } from './command.js';
+import { classifyHaikuFailure, logCommitMessageEvent, spawnHaikuWithPrompt, truncateDiff } from './haiku.js';
+import { extractCommitMessage, parseGitStatus } from './parsers.js';
+import { gitFail, gitOk } from './types.js';
+const haikuSucceeded = (r) => r.exitCode === 0 && r.stdout.trim().length > 0;
+const RETRY_TERMINAL_REASONS = new Set(['binary_missing', 'auth', 'rate_limit']);
+export const COMMIT_MESSAGE_SYSTEM_PROMPT = 'You are a commit message assistant. Respond with only the commit message — no preamble, no explanation, and never any Co-Authored-By or attribution lines.';
+export function buildCommitMessagePrompt(workingDir, inputs) {
+    return loadSkillPrompt('commit-message', { recentCommits: inputs.recentCommits, stagedFiles: inputs.stagedFiles, diff: inputs.diff }, workingDir)
+        ?? `You are generating a git commit message for the following staged changes.\n\nRECENT COMMIT MESSAGES (for style reference):\n${inputs.recentCommits}\n\nSTAGED FILES:\n${inputs.stagedFiles}\n\nDIFF OF STAGED CHANGES:\n${inputs.diff}\n\nGenerate a commit message: imperative mood, max 72 characters, focus on "why". Respond with ONLY the commit message. Never add Co-Authored-By or attribution lines.`;
+}
+export function classifyCommitMessageFailure(result) {
+    if (haikuSucceeded(result)) {
+        return { reason: 'empty_extraction', userMessage: 'Claude responded but no commit message could be extracted. Try again.' };
+    }
+    return classifyHaikuFailure(result);
+}
+export async function runHaikuForCommitMessage(prompt, systemPrompt, workingDir, meta) {
+    let result = await spawnHaikuWithPrompt(prompt, systemPrompt, workingDir);
+    let message = haikuSucceeded(result) ? extractCommitMessage(result.stdout) : '';
+    if (message)
+        return { result, attempts: 1, message };
+    const first = classifyCommitMessageFailure(result);
+    if (RETRY_TERMINAL_REASONS.has(first.reason))
+        return { result, attempts: 1, message: '' };
+    logCommitMessageEvent(workingDir, {
+        tabId: meta.tabId, attempt: 1, success: false, reason: first.reason,
+        exitCode: result.exitCode, timedOut: result.timedOut,
+        stderrTail: (result.stderr || '').trim().slice(-500),
+        stdoutTail: first.reason === 'empty_extraction' ? result.stdout.trim().slice(-300) : undefined,
+        latencyMs: Date.now() - meta.startedAt, diffBytes: meta.diffBytes, willRetry: true,
+    });
+    await new Promise(r => setTimeout(r, 500));
+    result = await spawnHaikuWithPrompt(prompt, systemPrompt, workingDir);
+    message = haikuSucceeded(result) ? extractCommitMessage(result.stdout) : '';
+    return { result, attempts: 2, message };
+}
+export async function generateStagedCommitMessage(args) {
+    const { cwd, tabId, startedAt, autoCommit } = args;
+    const statusResult = await executeGitCommand(['status', '--porcelain=v1'], cwd);
+    const { staged } = parseGitStatus(statusResult.stdout);
+    if (staged.length === 0) {
+        return gitFail('No staged changes to commit');
+    }
+    const diffResult = await executeGitCommand(['diff', '--cached'], cwd);
+    const logResult = await executeGitCommand(['log', '--oneline', '-5'], cwd);
+    const recentCommits = logResult.stdout.trim() || 'No recent commits';
+    const stagedFiles = staged.map(f => `${f.status} ${f.path}`).join('\n');
+    const diff = truncateDiff(diffResult.stdout);
+    const diffBytes = diffResult.stdout.length;
+    const prompt = buildCommitMessagePrompt(cwd, { recentCommits, stagedFiles, diff });
+    const { result, attempts, message: commitMessage } = await runHaikuForCommitMessage(prompt, COMMIT_MESSAGE_SYSTEM_PROMPT, cwd, { tabId, startedAt, diffBytes });
+    if (!commitMessage) {
+        const failure = classifyCommitMessageFailure(result);
+        logCommitMessageEvent(cwd, {
+            tabId, attempt: attempts, success: false, reason: failure.reason,
+            exitCode: result.exitCode, timedOut: result.timedOut,
+            stderrTail: (result.stderr || '').trim().slice(-500),
+            stdoutTail: failure.reason === 'empty_extraction' ? result.stdout.trim().slice(-300) : undefined,
+            latencyMs: Date.now() - startedAt, diffBytes,
+        });
+        console.error(`[git] commit-message failed (${failure.reason}):`, result.stderr || result.stdout.trim().slice(-300) || 'no output');
+        return gitFail(failure.userMessage);
+    }
+    logCommitMessageEvent(cwd, {
+        tabId, attempt: attempts, success: true,
+        latencyMs: Date.now() - startedAt, diffBytes, autoCommit,
+        messageLength: commitMessage.length,
+    });
+    return gitOk(commitMessage);
+}

package/dist/server/services/git/diff-ops.js

@@ -0,0 +1,56 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { executeGitCommand } from './command.js';
+import { parseCommitFiles, stripCoauthorLines } from './parsers.js';
+import { gitFail, gitOk } from './types.js';
+export async function readFileDiff({ cwd, path, staged }) {
+    const originalResult = await executeGitCommand(['show', `HEAD:${path}`], cwd);
+    const original = originalResult.exitCode === 0 ? originalResult.stdout : '';
+    let modified;
+    if (staged) {
+        const indexResult = await executeGitCommand(['show', `:${path}`], cwd);
+        modified = indexResult.exitCode === 0 ? indexResult.stdout : '';
+    }
+    else {
+        const fullPath = join(cwd, path);
+        try {
+            modified = readFileSync(fullPath, 'utf-8');
+        }
+        catch {
+            modified = '';
+        }
+    }
+    return { original, modified };
+}
+async function readCommitFiles(hash, cwd) {
+    const isRoot = (await executeGitCommand(['rev-parse', `${hash}^`], cwd)).exitCode !== 0;
+    const extra = isRoot ? ['--root'] : [];
+    const numstatResult = await executeGitCommand(['diff-tree', '-r', '--numstat', '--no-commit-id', ...extra, hash], cwd);
+    const statusResult = await executeGitCommand(['diff-tree', '-r', '--name-status', '--no-commit-id', ...extra, hash], cwd);
+    return parseCommitFiles(numstatResult.stdout, statusResult.stdout);
+}
+export async function readCommitDetail({ cwd, hash }) {
+    const metaResult = await executeGitCommand([
+        'show', '-s', '--format=%H%x00%h%x00%s%x00%b%x00%an%x00%aI', hash
+    ], cwd);
+    if (metaResult.exitCode !== 0) {
+        return gitFail(metaResult.stderr || 'Failed to get commit details');
+    }
+    const parts = metaResult.stdout.trim().split('\x00');
+    const subject = stripCoauthorLines(parts[2] || '') || parts[2] || '';
+    const files = await readCommitFiles(hash, cwd);
+    return gitOk({
+        hash: parts[0], shortHash: parts[1], subject,
+        body: stripCoauthorLines(parts[3] || '').trim(),
+        author: parts[4], date: parts[5], files,
+    });
+}
+export async function readCommitFileDiff({ cwd, hash, path }) {
+    const modifiedResult = await executeGitCommand(['show', `${hash}:${path}`], cwd);
+    const modified = modifiedResult.exitCode === 0 ? modifiedResult.stdout : '';
+    const originalResult = await executeGitCommand(['show', `${hash}^:${path}`], cwd);
+    const original = originalResult.exitCode === 0 ? originalResult.stdout : '';
+    return { original, modified };
+}

package/dist/server/services/git/haiku.js

@@ -0,0 +1,76 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { spawn } from 'node:child_process';
+import { appendFileSync, existsSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { resolveClaudeCommand } from '../../engines/claude/claude-command.js';
+import { spacePath } from '../space-layout.js';
+export function truncateDiff(diff, maxLength = 8000) {
+    if (diff.length <= maxLength)
+        return diff;
+    const headSize = Math.floor(maxLength / 2);
+    const tailSize = Math.floor(maxLength * 0.44);
+    return `${diff.slice(0, headSize)}\n\n... [diff truncated] ...\n\n${diff.slice(-tailSize)}`;
+}
+export function spawnHaikuWithPrompt(prompt, systemPrompt, workingDir, timeoutMs = 90000) {
+    return new Promise((resolve) => {
+        const args = ['--print', '--model', 'haiku', '--system-prompt', systemPrompt];
+        const proc = spawn(resolveClaudeCommand(), args, { cwd: workingDir, stdio: ['pipe', 'pipe', 'pipe'] });
+        let stdout = '';
+        let stderr = '';
+        let timedOut = false;
+        proc.stdout?.on('data', (d) => { stdout += d.toString(); });
+        proc.stderr?.on('data', (d) => { stderr += d.toString(); });
+        const timer = setTimeout(() => { timedOut = true; proc.kill(); }, timeoutMs);
+        proc.on('close', (code) => {
+            clearTimeout(timer);
+            resolve({ stdout, stderr, exitCode: code ?? 1, timedOut });
+        });
+        proc.on('error', (err) => {
+            clearTimeout(timer);
+            const enoent = err.code === 'ENOENT';
+            resolve({ stdout: '', stderr: enoent ? `claude: command not found (${err.message})` : err.message, exitCode: 1, timedOut: false });
+        });
+        proc.stdin?.on('error', () => { });
+        proc.stdin?.write(prompt);
+        proc.stdin?.end();
+    });
+}
+export function classifyHaikuFailure(result) {
+    const stderr = (result.stderr || '').toLowerCase();
+    const stdout = (result.stdout || '').toLowerCase();
+    const combined = `${stderr} ${stdout}`;
+    if (result.timedOut) {
+        return { reason: 'timeout', userMessage: 'Claude took too long to respond. Try again, or stage fewer files at once.' };
+    }
+    if (combined.includes('command not found') || combined.includes('enoent')) {
+        return { reason: 'binary_missing', userMessage: 'Claude Code was not found on the PATH minion started with or in its install locations. Install it (https://code.claude.com/docs/en/setup) and try again, or set CLAUDE_COMMAND to its full path and restart minion.' };
+    }
+    if (/not\s+(logged|signed)\s*in|not\s+authenticated|please\s+(log|sign)\s*in|api\s*key|unauthor/.test(combined)) {
+        return { reason: 'auth', userMessage: 'Claude CLI is not authenticated. Run `claude /login` in a terminal, then try again.' };
+    }
+    if (/rate\s*limit|usage\s*limit|429|too\s+many\s+requests/.test(combined)) {
+        return { reason: 'rate_limit', userMessage: 'Claude rate limit reached. Wait a minute and try again.' };
+    }
+    if (/overloaded|529|service\s+unavailable|503/.test(combined)) {
+        return { reason: 'overloaded', userMessage: "Claude is temporarily overloaded. Try again in a few seconds." };
+    }
+    if (result.exitCode === 0 && !result.stdout.trim()) {
+        return { reason: 'empty_output', userMessage: 'Claude returned an empty response. Try again.' };
+    }
+    const tail = (result.stderr || result.stdout || '').trim().slice(-200);
+    return { reason: 'unknown', userMessage: `Failed to generate commit message${tail ? `: ${tail}` : ''}` };
+}
+export function logCommitMessageEvent(workingDir, entry) {
+    try {
+        const logDir = spacePath(workingDir, 'logs');
+        if (!existsSync(logDir))
+            mkdirSync(logDir, { recursive: true });
+        const logFile = join(logDir, 'commit-message.jsonl');
+        const line = `${JSON.stringify({ timestamp: new Date().toISOString(), ...entry })}\n`;
+        appendFileSync(logFile, line, 'utf-8');
+    }
+    catch (err) {
+        console.error('[git] failed to write commit-message log:', err);
+    }
+}

package/dist/server/services/git/head-watcher.js

@@ -0,0 +1,226 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { existsSync, realpathSync, watch } from 'node:fs';
+import { basename, join, resolve } from 'node:path';
+import { executeGitCommand } from './command.js';
+import { listWorktrees } from './worktree-ops.js';
+const DEBOUNCE_MS = 300;
+const GIT_DIR_SPEC = {
+    recursive: false,
+    isRelevant: (filename) => filename === null || filename === 'HEAD' || filename === 'worktrees',
+};
+const WORKTREES_DIR_SPEC = {
+    recursive: true,
+    isRelevant: (filename) => filename === null || basename(filename) === 'HEAD',
+};
+function canonical(path) {
+    try {
+        return realpathSync(path);
+    }
+    catch {
+        return path;
+    }
+}
+function addTarget(targets, path) {
+    const key = canonical(path);
+    if (!targets.has(key))
+        targets.set(key, path);
+}
+async function resolveRepoDirs(dir) {
+    const result = await executeGitCommand(['rev-parse', '--path-format=absolute', '--git-dir', '--git-common-dir'], dir);
+    if (result.exitCode !== 0)
+        return null;
+    const [gitDir, commonDir] = result.stdout.split('\n').map((line) => line.trim());
+    if (!gitDir || !commonDir)
+        return null;
+    return { gitDir: canonical(resolve(dir, gitDir)), commonDir: canonical(resolve(dir, commonDir)) };
+}
+async function listWorktreePaths(dir) {
+    const listed = await listWorktrees({ cwd: dir });
+    if (!listed.ok)
+        return [];
+    return listed.value.filter((wt) => !wt.isBare && !wt.prunable).map((wt) => wt.path);
+}
+async function readBranch(dir) {
+    const result = await executeGitCommand(['rev-parse', '--abbrev-ref', 'HEAD'], dir);
+    if (result.exitCode !== 0)
+        return null;
+    return result.stdout.trim() || null;
+}
+export class GitHeadWatcher {
+    workingDir;
+    hooks;
+    watchers = new Map();
+    debounceTimer = null;
+    lastKnownBranch = null;
+    lastKnownWorktreeBranches = new Map();
+    chain = Promise.resolve();
+    pendingPass = null;
+    started = false;
+    constructor(workingDir, hooks) {
+        this.workingDir = workingDir;
+        this.hooks = hooks;
+    }
+    start() {
+        if (this.started)
+            return;
+        this.started = true;
+        this.retrack();
+    }
+    startWorktreeWatcher() {
+        this.retrack();
+    }
+    retrack() {
+        void this.checkNow();
+    }
+    checkNow() {
+        if (!this.pendingPass) {
+            this.pendingPass = this.enqueue(() => {
+                this.pendingPass = null;
+                return this.runPass();
+            });
+        }
+        return this.pendingPass;
+    }
+    stop() {
+        for (const watcher of this.watchers.values())
+            watcher.close();
+        this.watchers.clear();
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+            this.debounceTimer = null;
+        }
+        this.started = false;
+    }
+    enqueue(task) {
+        const run = this.chain.then(task);
+        this.chain = run.catch(() => undefined);
+        return run;
+    }
+    async runPass() {
+        if (!this.started)
+            return;
+        try {
+            const plan = await this.scan();
+            await this.checkMainBranch();
+            await this.checkWorktreeBranches(plan.targets);
+            this.syncWatchers(plan);
+        }
+        catch {
+        }
+    }
+    async scan() {
+        const plan = { gitDirs: new Set(), worktreesDirs: new Set(), targets: new Map() };
+        const repoDirs = new Map();
+        for (const dir of this.dirsInPlay()) {
+            const repo = await resolveRepoDirs(dir);
+            if (!repo)
+                continue;
+            plan.gitDirs.add(repo.gitDir);
+            plan.worktreesDirs.add(join(repo.commonDir, 'worktrees'));
+            if (!repoDirs.has(repo.commonDir))
+                repoDirs.set(repo.commonDir, dir);
+            addTarget(plan.targets, dir);
+        }
+        for (const dir of repoDirs.values()) {
+            for (const path of await listWorktreePaths(dir))
+                addTarget(plan.targets, path);
+        }
+        plan.targets.delete(canonical(this.workingDir));
+        return plan;
+    }
+    dirsInPlay() {
+        const dirs = new Set([this.workingDir]);
+        for (const [, dir] of this.hooks.trackedWorktrees())
+            dirs.add(dir);
+        for (const dir of this.hooks.trackedRepoRoots())
+            dirs.add(dir);
+        return [...dirs];
+    }
+    async checkMainBranch() {
+        const branch = await readBranch(this.workingDir);
+        if (!branch)
+            return;
+        const last = this.lastKnownBranch;
+        this.lastKnownBranch = branch;
+        if (last === null || last === branch)
+            return;
+        this.hooks.onMainBranchChanged(this.workingDir, branch);
+    }
+    async checkWorktreeBranches(targets) {
+        for (const [key, path] of targets) {
+            try {
+                await this.checkWorktreeBranch(key, path);
+            }
+            catch {
+            }
+        }
+        for (const key of this.lastKnownWorktreeBranches.keys()) {
+            if (!targets.has(key))
+                this.lastKnownWorktreeBranches.delete(key);
+        }
+    }
+    async checkWorktreeBranch(key, path) {
+        const branch = await readBranch(path);
+        if (!branch || branch === 'HEAD')
+            return;
+        const last = this.lastKnownWorktreeBranches.get(key);
+        this.lastKnownWorktreeBranches.set(key, branch);
+        if (last === undefined || last === branch)
+            return;
+        this.hooks.onWorktreeBranchChanged(this.labelFor(key), path, branch);
+    }
+    labelFor(key) {
+        for (const [label, dir] of this.hooks.trackedWorktrees()) {
+            if (canonical(dir) === key)
+                return label;
+        }
+        return null;
+    }
+    syncWatchers(plan) {
+        if (!this.started)
+            return;
+        const wanted = new Map();
+        for (const gitDir of plan.gitDirs)
+            wanted.set(gitDir, GIT_DIR_SPEC);
+        for (const dir of plan.worktreesDirs) {
+            if (existsSync(dir))
+                wanted.set(dir, WORKTREES_DIR_SPEC);
+        }
+        for (const path of this.watchers.keys()) {
+            if (!wanted.has(path))
+                this.dropWatcher(path);
+        }
+        for (const [path, spec] of wanted) {
+            if (!this.watchers.has(path))
+                this.addWatcher(path, spec);
+        }
+    }
+    addWatcher(path, spec) {
+        try {
+            const watcher = watch(path, { recursive: spec.recursive }, (_event, filename) => {
+                if (spec.isRelevant(filename))
+                    this.debounce();
+            });
+            watcher.on('error', () => this.dropWatcher(path));
+            this.watchers.set(path, watcher);
+        }
+        catch {
+        }
+    }
+    dropWatcher(path) {
+        const watcher = this.watchers.get(path);
+        if (!watcher)
+            return;
+        watcher.close();
+        this.watchers.delete(path);
+    }
+    debounce() {
+        if (this.debounceTimer)
+            clearTimeout(this.debounceTimer);
+        this.debounceTimer = setTimeout(() => {
+            this.debounceTimer = null;
+            void this.checkNow();
+        }, DEBOUNCE_MS);
+    }
+}

package/dist/server/services/git/index.js

@@ -0,0 +1,17 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+export * from './branch-ops.js';
+export * from './command.js';
+export * from './commit-message.js';
+export * from './diff-ops.js';
+export * from './haiku.js';
+export { GitHeadWatcher } from './head-watcher.js';
+export * from './log-ops.js';
+export * from './merge-ops.js';
+export * from './parsers.js';
+export * from './remote-ops.js';
+export * from './status-ops.js';
+export * from './suggestion-ops.js';
+export * from './tag-ops.js';
+export * from './types.js';
+export * from './worktree-ops.js';

package/dist/server/services/git/log-ops.js

@@ -0,0 +1,98 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { existsSync, readdirSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { executeGitCommand, gitErrorText } from './command.js';
+import { buildGitLogArgs, parseLogEntries, parseWorktreePorcelain } from './parsers.js';
+import { gitFail, gitOk } from './types.js';
+import { isInsideGitRepo } from './worktree-ops.js';
+export async function readLog({ cwd, limit, skip, search }) {
+    const args = buildGitLogArgs({ limit, skip, search });
+    const result = await executeGitCommand(args, cwd);
+    if (result.exitCode !== 0) {
+        return gitFail(gitErrorText(result, 'Failed to get log'));
+    }
+    const allEntries = parseLogEntries(result.stdout);
+    const hasMore = allEntries.length > limit;
+    return gitOk({ entries: hasMore ? allEntries.slice(0, limit) : allEntries, hasMore });
+}
+const SKIP_DIRS = ['node_modules', 'vendor', '.git'];
+function shouldSkipDir(name) {
+    return name.startsWith('.') || SKIP_DIRS.includes(name);
+}
+async function getRepoBranch(repoPath) {
+    const result = await executeGitCommand(['rev-parse', '--abbrev-ref', 'HEAD'], repoPath);
+    return result.exitCode === 0 ? result.stdout.trim() : undefined;
+}
+async function getRepoWorktrees(repoPath) {
+    const result = await executeGitCommand(['worktree', 'list', '--porcelain'], repoPath);
+    return result.exitCode === 0 ? parseWorktreePorcelain(result.stdout) : undefined;
+}
+async function scanForGitRepos(dir, depth, maxDepth, repos) {
+    if (depth > maxDepth)
+        return;
+    let entries;
+    try {
+        entries = readdirSync(dir);
+    }
+    catch {
+        return;
+    }
+    for (const name of entries) {
+        if (shouldSkipDir(name))
+            continue;
+        const fullPath = join(dir, name);
+        const gitPath = join(fullPath, '.git');
+        if (existsSync(gitPath)) {
+            repos.push({ path: fullPath, name, branch: await getRepoBranch(fullPath), worktrees: await getRepoWorktrees(fullPath) });
+        }
+        else {
+            await scanForGitRepos(fullPath, depth + 1, maxDepth, repos);
+        }
+    }
+}
+export async function discoverRepos({ cwd }) {
+    const repos = [];
+    const rootIsGitRepo = existsSync(join(cwd, '.git'));
+    if (rootIsGitRepo) {
+        repos.push({
+            path: cwd,
+            name: cwd.split('/').pop() || cwd,
+            branch: await getRepoBranch(cwd),
+            worktrees: await getRepoWorktrees(cwd),
+        });
+    }
+    else {
+        await scanForGitRepos(cwd, 1, 3, repos);
+    }
+    return { repos, rootIsGitRepo };
+}
+export async function isValidWorktreePath(targetPath, cwd) {
+    const result = await executeGitCommand(['worktree', 'list', '--porcelain'], cwd);
+    if (result.exitCode !== 0)
+        return false;
+    const resolvedTarget = resolve(targetPath);
+    for (const line of result.stdout.split('\n')) {
+        if (line.startsWith('worktree ')) {
+            const wtPath = resolve(line.slice(9).trim());
+            if (wtPath === resolvedTarget)
+                return true;
+        }
+    }
+    return false;
+}
+export async function resolveGitDirectory({ cwd, directory, allowCustom }) {
+    const resolvedDir = resolve(directory);
+    const resolvedWorkingDir = resolve(cwd);
+    if (resolvedDir !== resolvedWorkingDir) {
+        const { repos } = await discoverRepos({ cwd });
+        const isDiscovered = repos.some((repo) => resolve(repo.path) === resolvedDir || (repo.worktrees ?? []).some((wt) => resolve(wt.path) === resolvedDir));
+        if (!isDiscovered && !(allowCustom && (await isInsideGitRepo(resolvedDir)))) {
+            return gitFail('Access denied: path outside project directory');
+        }
+    }
+    return gitOk({ directory: resolvedDir, isValid: existsSync(join(resolvedDir, '.git')) });
+}
+export function isGitRepoRoot(dir) {
+    return existsSync(join(dir, '.git'));
+}