@stubbedev/atlassian-mcp 0.1.19 → 0.2.1

package/dist/bitbucket.js

@@ -197,11 +197,29 @@ export class BitbucketClient {
         }
         return `${this.baseUrl}/projects/${encodeURIComponent(projectKey)}/repos/${encodeURIComponent(repoSlug)}/pull-requests/${prId}`;
     }
+    configuredHostname() {
+        try {
+            return new URL(this.baseUrl).hostname.toLowerCase();
+        }
+        catch {
+            return '';
+        }
+    }
+    remoteMatchesInstance(remote) {
+        const host = this.configuredHostname();
+        if (!host)
+            return true; // can't validate, allow
+        return remote.toLowerCase().includes(host);
+    }
     resolveProjectAndRepo(projectKey, repoSlug) {
         if (projectKey && repoSlug)
             return { projectKey, repoSlug };
         const remote = safeExec('git remote get-url origin');
         if (remote) {
+            if (!this.remoteMatchesInstance(remote)) {
+                throw new Error(`This repo's remote does not point to your configured Bitbucket instance (${this.baseUrl}). ` +
+                    `Bitbucket tools only work with repos hosted on that instance.`);
+            }
             const parsed = parseBitbucketRemote(remote);
             if (parsed) {
                 return {
@@ -210,7 +228,7 @@ export class BitbucketClient {
                 };
             }
         }
-        throw new Error('Could not determine projectKey/repoSlug — provide them explicitly or run from a directory inside a git repo with a Bitbucket remote');
+        throw new Error('Could not determine projectKey/repoSlug — provide them explicitly or run from a directory with a Bitbucket remote');
     }
     async request(method, path, body) {
         const url = `${this.baseUrl}/rest/api/1.0${path}`;
@@ -238,6 +256,21 @@ export class BitbucketClient {
         }
         return res.text();
     }
+    async requestBuildStatus(method, path, body) {
+        const url = `${this.baseUrl}/rest/build-status/1.0${path}`;
+        const opts = { method, headers: this.headers };
+        if (body !== undefined)
+            opts.body = JSON.stringify(body);
+        const res = await fetch(url, opts);
+        if (res.status === 404)
+            return null; // no build status yet
+        if (!res.ok) {
+            const errText = await res.text();
+            const details = parseBitbucketErrorDetails(errText);
+            throw new Error(formatBitbucketError(res.status, method, path, details));
+        }
+        return res.status === 204 ? null : res.json();
+    }
     normalizeIdentity(value) {
         return (value ?? '').trim().toLowerCase();
     }
@@ -270,6 +303,10 @@ export class BitbucketClient {
         }
         throw new Error(`You can only edit your own Bitbucket comments. Comment #${comment.id} is authored by ${comment.author?.displayName ?? comment.author?.name ?? 'another user'}.`);
     }
+    /** Returns true if the given remote URL belongs to this Bitbucket instance. */
+    isRemoteForThisInstance(remoteUrl) {
+        return this.remoteMatchesInstance(remoteUrl);
+    }
     // Used internally by context tools — finds the open PR for a given source branch
     async findOpenPrForBranch(projectKey, repoSlug, branch) {
         const targetBranch = branchDisplayId(branch);
@@ -352,12 +389,40 @@ export class BitbucketClient {
         const includeCommits = args.includeCommits ?? true;
         const includeComments = args.includeComments ?? true;
         const includeDiff = args.includeDiff ?? false;
-        const pr = await this.request('GET', `/projects/${projectKey}/repos/${repoSlug}/pull-requests/${args.prId}`);
+        const includeBuildStatus = args.includeBuildStatus ?? true;
+        let prId = args.prId;
+        if (prId === undefined) {
+            const branch = args.fromBranch ?? safeExec('git rev-parse --abbrev-ref HEAD');
+            if (!branch || branch === 'HEAD') {
+                throw new Error('Provide prId or fromBranch, or run from a checked-out branch.');
+            }
+            const found = await this.findOpenPrForBranch(projectKey, repoSlug, branch);
+            if (!found)
+                throw new Error(`No open PR found for branch "${branchDisplayId(branch)}".`);
+            prId = found.id;
+        }
+        const [pr, me] = await Promise.all([
+            this.request('GET', `/projects/${projectKey}/repos/${repoSlug}/pull-requests/${prId}`),
+            this.getCurrentUser().catch(() => null),
+        ]);
         if (!pr)
             return text('Pull request not found.');
         const sections = [];
         const reviewers = pr.reviewers.map((r) => `${r.user.displayName}${r.approved ? ' ✓' : ''}`).join(', ');
         const url = pr.links?.self?.[0]?.href;
+        // Prefer slug (canonical unique identifier), fall back to username (name field).
+        // Display name is deliberately excluded — it is not unique.
+        const meSlug = this.normalizeIdentity(me?.slug);
+        const meName = this.normalizeIdentity(me?.name);
+        const authorSlug = this.normalizeIdentity(pr.author.user.slug);
+        const authorName = this.normalizeIdentity(pr.author.user.name);
+        const isAuthor = me
+            ? (meSlug && authorSlug ? meSlug === authorSlug : false) ||
+                (meName && authorName ? meName === authorName : false)
+            : false;
+        const viewingAs = me
+            ? `Viewing as: ${me.displayName} (${isAuthor ? 'you are the author' : 'you are a reviewer'})`
+            : '';
         const header = [
             `PR #${pr.id}: ${pr.title}`,
             `State:     ${pr.state}`,
@@ -365,15 +430,29 @@ export class BitbucketClient {
             `Branch:    ${pr.fromRef.displayId} → ${pr.toRef.displayId}`,
             `Reviewers: ${reviewers || 'None'}`,
             url ? `URL:       ${url}` : '',
+            viewingAs,
             '',
             'Description:',
             pr.description ?? '(no description)',
         ].filter((line) => line !== '');
         sections.push(header.join('\n'));
+        if (includeBuildStatus && pr.fromRef.latestCommit) {
+            const statuses = await this.requestBuildStatus('GET', `/commits/${pr.fromRef.latestCommit}`).catch(() => null);
+            if (statuses?.values?.length) {
+                const statusLines = statuses.values.map((s) => {
+                    const icon = s.state === 'SUCCESSFUL' ? '✓' : s.state === 'FAILED' ? '✗' : '…';
+                    return `${icon} [${s.state}] ${s.name ?? s.key}${s.description ? ` — ${s.description}` : ''}`;
+                });
+                sections.push(`Build status (${pr.fromRef.latestCommit.slice(0, 8)}):\n${statusLines.join('\n')}`);
+            }
+            else {
+                sections.push(`Build status: none reported for ${pr.fromRef.latestCommit.slice(0, 8)}`);
+            }
+        }
         if (includeCommits) {
             const commitsLimit = args.commitsLimit ?? 25;
             const commitsStart = args.commitsStart ?? 0;
-            const data = await this.request('GET', `/projects/${projectKey}/repos/${repoSlug}/pull-requests/${args.prId}/commits?limit=${commitsLimit}&start=${commitsStart}`);
+            const data = await this.request('GET', `/projects/${projectKey}/repos/${repoSlug}/pull-requests/${prId}/commits?limit=${commitsLimit}&start=${commitsStart}`);
             if (!data || data.values.length === 0) {
                 sections.push('Commits:\n(no commits found)');
             }
@@ -392,7 +471,7 @@ export class BitbucketClient {
             }
             if (commentsSeverity === 'BLOCKER') {
                 const qs = new URLSearchParams({ limit: String(commentsLimit), start: String(commentsStart), state: commentsState });
-                const data = await this.request('GET', `/projects/${projectKey}/repos/${repoSlug}/pull-requests/${args.prId}/blocker-comments?${qs}`);
+                const data = await this.request('GET', `/projects/${projectKey}/repos/${repoSlug}/pull-requests/${prId}/blocker-comments?${qs}`);
                 if (!data || data.values.length === 0) {
                     sections.push(`Comments:\n(no ${commentsState} BLOCKER comments)`);
                 }
@@ -402,7 +481,7 @@ export class BitbucketClient {
                 }
             }
             else {
-                const activityData = await this.request('GET', `/projects/${projectKey}/repos/${repoSlug}/pull-requests/${args.prId}/activities?limit=${commentsLimit}&start=${commentsStart}`);
+                const activityData = await this.request('GET', `/projects/${projectKey}/repos/${repoSlug}/pull-requests/${prId}/activities?limit=${commentsLimit}&start=${commentsStart}`);
                 const comments = uniqueCommentsFromActivities(activityData?.values ?? []).filter((comment) => {
                     const matchesState = commentMatchesState(comment, commentsState);
                     return matchesState && commentMatchesSeverity(comment, commentsSeverity);
@@ -418,7 +497,7 @@ export class BitbucketClient {
             }
         }
         if (includeDiff) {
-            const data = await this.request('GET', `/projects/${projectKey}/repos/${repoSlug}/pull-requests/${args.prId}/diff`);
+            const data = await this.request('GET', `/projects/${projectKey}/repos/${repoSlug}/pull-requests/${prId}/diff`);
             sections.push(`Diff:\n${data ? formatDiff(data, args.diffMaxChars ?? 8000) : '(no diff found)'}`);
         }
         return text(sections.join('\n\n'));
@@ -612,6 +691,24 @@ export class BitbucketClient {
             return text(`Merged PR #${args.prId}.\n${this.pullRequestUrl(projectKey, repoSlug, args.prId)}`);
         return text(`Merged PR #${data.id}: "${data.title}" (${data.fromRef.displayId} → ${data.toRef.displayId}).\n${this.pullRequestUrl(projectKey, repoSlug, data.id, data)}`);
     }
+    async getDefaultBranchRef(projectKey, repoSlug) {
+        const data = await this.request('GET', `/projects/${projectKey}/repos/${repoSlug}/default-branch`);
+        if (data?.displayId)
+            return `refs/heads/${data.displayId}`;
+        // Fallback: detect from local git
+        const head = safeExec('git rev-parse --abbrev-ref origin/HEAD');
+        if (head.startsWith('origin/'))
+            return `refs/heads/${head.slice('origin/'.length)}`;
+        return 'refs/heads/master';
+    }
+    async createBranch(args) {
+        const { projectKey, repoSlug } = this.resolveProjectAndRepo(args.projectKey, args.repoSlug);
+        const startPoint = args.startPoint ?? await this.getDefaultBranchRef(projectKey, repoSlug);
+        const data = await this.request('POST', `/projects/${projectKey}/repos/${repoSlug}/branches`, { name: args.branchName, startPoint });
+        if (!data)
+            return text(`Branch "${args.branchName}" created.`);
+        return text(`Created branch "${data.displayId}" at ${data.latestCommit.slice(0, 8)} in ${projectKey}/${repoSlug}.`);
+    }
     async getBranches(args) {
         const { projectKey, repoSlug } = this.resolveProjectAndRepo(args.projectKey, args.repoSlug);
         const qs = new URLSearchParams({ limit: String(args.limit ?? 25), start: String(args.start ?? 0) });
@@ -856,4 +953,72 @@ export class BitbucketClient {
         await this.request('DELETE', path);
         return text(`Comment #${args.commentId} deleted from PR #${args.prId}.`);
     }
+    async getPrTasks(args) {
+        const { projectKey, repoSlug } = this.resolveProjectAndRepo(args.projectKey, args.repoSlug);
+        const data = await this.request('GET', `/projects/${projectKey}/repos/${repoSlug}/pull-requests/${args.prId}/tasks`);
+        if (!data || data.values.length === 0)
+            return text(`No tasks on PR #${args.prId}.`);
+        const lines = data.values.map((t) => {
+            const author = t.author?.displayName ?? t.author?.name ?? 'Unknown';
+            const date = t.createdDate ? ` (${formatDate(t.createdDate)})` : '';
+            const anchor = t.anchor?.id ? ` [on comment #${t.anchor.id}]` : '';
+            return `#${t.id} [${t.state}] ${author}${date}${anchor}: ${t.text}`;
+        });
+        const open = data.values.filter((t) => t.state === 'OPEN').length;
+        return text(`${data.values.length} task(s) on PR #${args.prId} (${open} open)${pageHint(data)}:\n${lines.join('\n')}`);
+    }
+    async mutatePrTask(args) {
+        const { projectKey, repoSlug } = this.resolveProjectAndRepo(args.projectKey, args.repoSlug);
+        if (args.action === 'create') {
+            if (!args.text)
+                throw new Error('text is required to create a task.');
+            const body = { text: args.text };
+            if (args.commentId !== undefined) {
+                body.anchor = { id: args.commentId, type: 'COMMENT' };
+            }
+            else if (args.prId !== undefined) {
+                body.anchor = { id: args.prId, type: 'PULL_REQUEST' };
+            }
+            else {
+                throw new Error('Provide prId or commentId to anchor the task.');
+            }
+            const created = await this.request('POST', '/tasks', body);
+            if (!created)
+                return text('Task created.');
+            return text(`Task #${created.id} created: "${created.text}"`);
+        }
+        if (!args.taskId)
+            throw new Error('taskId is required for resolve/reopen/delete.');
+        if (args.action === 'delete') {
+            const task = await this.request('GET', `/tasks/${args.taskId}`);
+            if (!task)
+                throw new Error(`Task #${args.taskId} not found.`);
+            await this.request('DELETE', `/tasks/${args.taskId}?version=${task.id}`);
+            return text(`Task #${args.taskId} deleted.`);
+        }
+        // resolve or reopen
+        const task = await this.request('GET', `/tasks/${args.taskId}`);
+        if (!task)
+            throw new Error(`Task #${args.taskId} not found.`);
+        const newState = args.action === 'resolve' ? 'RESOLVED' : 'OPEN';
+        const updated = await this.request('PUT', `/tasks/${args.taskId}`, {
+            id: task.id,
+            state: newState,
+            text: task.text,
+        });
+        if (!updated)
+            return text(`Task #${args.taskId} ${newState}.`);
+        return text(`Task #${updated.id} is now ${updated.state}: "${updated.text}"`);
+    }
+    async getBuildStatuses(args) {
+        const data = await this.requestBuildStatus('GET', `/commits/${args.commitSha}`);
+        if (!data?.values?.length)
+            return text(`No build statuses reported for ${args.commitSha}.`);
+        const lines = data.values.map((s) => {
+            const icon = s.state === 'SUCCESSFUL' ? '✓' : s.state === 'FAILED' ? '✗' : '…';
+            const date = s.dateAdded ? ` (${new Date(s.dateAdded).toISOString().slice(0, 10)})` : '';
+            return `${icon} [${s.state}] ${s.name ?? s.key}${date}${s.description ? `\n  ${s.description}` : ''}${s.url ? `\n  ${s.url}` : ''}`;
+        });
+        return text(`${data.values.length} build status(es) for ${args.commitSha.slice(0, 8)}:\n${lines.join('\n')}`);
+    }
 }

package/dist/config.js

@@ -34,21 +34,28 @@ export function loadConfig() {
     const jiraToken = file?.jira?.token ?? process.env.JIRA_ACCESS_TOKEN ?? '';
     const bitbucketUrl = file?.bitbucket?.url ?? process.env.BITBUCKET_URL ?? '';
     const bitbucketToken = file?.bitbucket?.token ?? process.env.BITBUCKET_ACCESS_TOKEN ?? '';
-    const missing = [];
-    if (!jiraUrl)
-        missing.push('jira.url (or JIRA_URL)');
-    if (!jiraToken)
-        missing.push('jira.token (or JIRA_ACCESS_TOKEN)');
-    if (!bitbucketUrl)
-        missing.push('bitbucket.url (or BITBUCKET_URL)');
-    if (!bitbucketToken)
-        missing.push('bitbucket.token (or BITBUCKET_ACCESS_TOKEN)');
-    if (missing.length > 0) {
-        throw new Error(`Missing required configuration: ${missing.join(', ')}.\n` +
-            'Provide a config file (~/.atlassian-mcp.json or --config <path>) or set environment variables.');
-    }
-    return {
-        jira: { url: jiraUrl, token: jiraToken },
-        bitbucket: { url: bitbucketUrl, token: bitbucketToken },
-    };
+    const config = {};
+    if (jiraUrl && jiraToken) {
+        config.jira = { url: jiraUrl, token: jiraToken };
+    }
+    else {
+        const missing = [];
+        if (!jiraUrl)
+            missing.push('jira.url (or JIRA_URL)');
+        if (!jiraToken)
+            missing.push('jira.token (or JIRA_ACCESS_TOKEN)');
+        console.error(`[atlassian-mcp] Jira disabled: missing ${missing.join(', ')}`);
+    }
+    if (bitbucketUrl && bitbucketToken) {
+        config.bitbucket = { url: bitbucketUrl, token: bitbucketToken };
+    }
+    else {
+        const missing = [];
+        if (!bitbucketUrl)
+            missing.push('bitbucket.url (or BITBUCKET_URL)');
+        if (!bitbucketToken)
+            missing.push('bitbucket.token (or BITBUCKET_ACCESS_TOKEN)');
+        console.error(`[atlassian-mcp] Bitbucket disabled: missing ${missing.join(', ')}`);
+    }
+    return config;
 }

package/dist/context.js

@@ -11,6 +11,7 @@ function safeExec(cmd, cwd) {
 }
 /**
  * Unified developer context: git state + linked Jira issues + open PR for current branch.
+ * Either jira or bitbucket may be null when only one product is configured.
  */
 export async function getDevContext(args, jira, bitbucket) {
     const repoPath = args.repoPath ?? process.cwd();
@@ -30,38 +31,65 @@ export async function getDevContext(args, jira, bitbucket) {
         'Working tree:',
         status,
     ].join('\n'));
-    // Jira — fetch any tickets referenced in the branch name
-    const jiraKeys = [...new Set(branch.match(JIRA_KEY_RE) ?? [])];
+    // Jira — fetch overview for any tickets referenced in the branch name
+    const jiraKeys = jira ? [...new Set(branch.match(JIRA_KEY_RE) ?? [])] : [];
     for (const key of jiraKeys) {
         try {
-            const result = await jira.getIssue({ issueKey: key });
+            const result = await jira.issueOverview({
+                issueKey: key,
+                includeComments: true,
+                commentsMaxResults: 5,
+                includeTransitions: true,
+                includeSprint: true,
+            });
             sections.push(`── Jira ${key} ──\n${result.content[0].text}`);
         }
         catch {
             sections.push(`── Jira ${key} ── (could not fetch)`);
         }
     }
-    // Bitbucket — find the open PR for this branch
-    const parsed = parseBitbucketRemote(remote);
+    // Bitbucket — find the open PR for this branch (only if remote points to this instance)
+    const parsed = bitbucket?.isRemoteForThisInstance(remote) ? parseBitbucketRemote(remote) : null;
     if (parsed) {
         try {
             const pr = await bitbucket.findOpenPrForBranch(parsed.projectKey, parsed.repoSlug, branch);
             if (pr) {
+                const approved = pr.reviewers.filter((r) => r.approved).length;
+                const total = pr.reviewers.length;
                 const reviewers = pr.reviewers.map((r) => `${r.user.displayName}${r.approved ? ' ✓' : ''}`).join(', ');
                 const url = pr.links?.self?.[0]?.href ?? '';
+                const descSnippet = pr.description
+                    ? pr.description.slice(0, 200) + (pr.description.length > 200 ? '…' : '')
+                    : '';
                 const prLines = [
                     `── PR #${pr.id}: ${pr.title} ──`,
                     `State:     ${pr.state}`,
                     `Author:    ${pr.author.user.displayName}`,
                     `Branch:    ${pr.fromRef.displayId} → ${pr.toRef.displayId}`,
-                    `Reviewers: ${reviewers || 'None'}`,
+                    `Reviewers: ${reviewers || 'none'} (${approved}/${total} approved)`,
                 ];
                 if (url)
                     prLines.push(`URL:       ${url}`);
+                if (descSnippet)
+                    prLines.push(``, descSnippet);
+                // Workflow hint
+                if (total > 0 && approved === total) {
+                    prLines.push(``, `✓ All reviewers approved — ready to merge: bitbucket_mutate {prId: ${pr.id}, action: "merge"}`);
+                }
+                else if (total > 0) {
+                    prLines.push(``, `→ ${total - approved} reviewer(s) pending — use bitbucket_get_pr {prId: ${pr.id}} to see open comments`);
+                }
+                else {
+                    prLines.push(``, `→ No reviewers assigned — use bitbucket_mutate {prId: ${pr.id}, update: {reviewers: [...]}} to add them`);
+                }
                 sections.push(prLines.join('\n'));
             }
             else {
-                sections.push(`── Bitbucket (${parsed.projectKey}/${parsed.repoSlug}) ── No open PR for branch "${branch}"`);
+                const noPrHint = [
+                    `── Bitbucket (${parsed.projectKey}/${parsed.repoSlug}) ── No open PR for branch "${branch}"`,
+                    `→ Create one: bitbucket_mutate {create: {title: "...", fromBranch: "${branch}"}}`,
+                ];
+                sections.push(noPrHint.join('\n'));
             }
         }
         catch {

package/dist/git.js

@@ -22,16 +22,52 @@ export function getContext(args) {
         const remote = safeGit('remote get-url origin', repoPath, '(no remote)');
         const commits = safeGit(`log --oneline -${limit}`, repoPath, '(no commits)');
         const status = safeGit('status --short', repoPath, '');
+        // Upstream tracking
+        const upstream = safeGit('rev-parse --abbrev-ref @{u}', repoPath, '');
+        let upstreamLine = '';
+        if (upstream) {
+            const ab = safeGit(`rev-list --left-right --count ${upstream}...HEAD`, repoPath, '');
+            if (ab.includes('\t')) {
+                const [behind, ahead] = ab.split('\t').map(Number);
+                const parts = [];
+                if (ahead)
+                    parts.push(`${ahead} ahead`);
+                if (behind)
+                    parts.push(`${behind} behind`);
+                upstreamLine = `${upstream}${parts.length ? ` (${parts.join(', ')})` : ' (up to date)'}`;
+            }
+        }
+        // Diff stat summary
+        const diffStatLines = safeGit('diff HEAD --stat', repoPath, '').split('\n').filter(Boolean);
+        const diffStat = diffStatLines[diffStatLines.length - 1]?.trim() ?? '';
         const jiraKeys = [...new Set(branch.match(JIRA_KEY_RE) ?? [])];
         const lines = [
             `Repository: ${repoPath}`,
             `Branch:     ${branch}`,
+            ...(upstreamLine ? [`Upstream:   ${upstreamLine}`] : []),
             `Remote:     ${remote}`,
+            ...(jiraKeys.length ? [`Jira:       ${jiraKeys.join(', ')}`] : []),
+            '',
+            `Recent commits (last ${limit}):`,
+            commits || '(none)',
+            '',
+            'Working tree:',
         ];
-        if (jiraKeys.length > 0) {
-            lines.push(`Jira issue(s) detected in branch: ${jiraKeys.join(', ')}`);
+        if (status) {
+            lines.push(status);
+            if (diffStat)
+                lines.push('', `Diff stat:  ${diffStat}`);
+        }
+        else {
+            lines.push('(clean)');
+        }
+        if (args.includeDiff && status) {
+            const diff = safeGit('diff HEAD', repoPath, '');
+            if (diff) {
+                const MAX = 6000;
+                lines.push('', '── Uncommitted diff ──', diff.length > MAX ? diff.slice(0, MAX) + `\n\n... (truncated, ${diff.length - MAX} more chars)` : diff);
+            }
         }
-        lines.push('', `Recent commits (last ${limit}):`, commits || '(none)', '', 'Working tree status:', status || '(clean)');
         return text(lines.join('\n'));
     }
     catch (err) {
@@ -84,3 +120,70 @@ export function getDiff(args) {
         return text(`Error reading diff: ${err.message}`);
     }
 }
+export function checkRemoteBranch(branchName, repoPath) {
+    const lsRemote = safeGit(`ls-remote --heads origin refs/heads/${branchName}`, repoPath);
+    if (!lsRemote)
+        return { exists: false };
+    const sha = lsRemote.split(/\s+/)[0]?.trim();
+    // Fetch so we can read the log
+    safeGit(`fetch origin ${branchName}`, repoPath);
+    const log = safeGit(`log origin/${branchName} -1 --format=%an%x09%ae%x09%ad%x09%s`, repoPath);
+    if (!log)
+        return { exists: true, sha: sha?.slice(0, 8) };
+    const [author, email, date, ...msgParts] = log.split('\t');
+    return {
+        exists: true,
+        sha: sha?.slice(0, 8),
+        author: email ? `${author} <${email}>` : author,
+        date,
+        message: msgParts.join('\t'),
+    };
+}
+function getDefaultBranch(repoPath) {
+    const head = safeGit('rev-parse --abbrev-ref origin/HEAD', repoPath);
+    if (head && head.startsWith('origin/'))
+        return head.slice('origin/'.length);
+    // origin/HEAD not set — probe common defaults
+    if (safeGit('rev-parse --verify origin/main', repoPath))
+        return 'main';
+    return 'master';
+}
+export function checkoutRemoteBranch(branchName, repoPath) {
+    try {
+        const existing = safeGit(`branch --list ${branchName}`, repoPath);
+        if (existing.trim()) {
+            git(`checkout ${branchName}`, repoPath);
+            return text(`Switched to existing local branch "${branchName}".`);
+        }
+        git(`checkout --track origin/${branchName}`, repoPath);
+        return text(`Checked out "${branchName}" tracking origin/${branchName}.`);
+    }
+    catch (err) {
+        return text(`Error checking out branch: ${err.message}`);
+    }
+}
+export function createBranch(args) {
+    const repoPath = args.repoPath ?? process.cwd();
+    const { branchName, push = false } = args;
+    const baseBranch = args.baseBranch ?? getDefaultBranch(repoPath);
+    try {
+        if (!/^[a-zA-Z0-9/_.\-]+$/.test(branchName)) {
+            return text(`Invalid branch name "${branchName}". Use only letters, numbers, /, _, ., -`);
+        }
+        const existing = safeGit(`branch --list ${branchName}`, repoPath);
+        if (existing.trim()) {
+            return text(`Branch "${branchName}" already exists locally. Switch with: git checkout ${branchName}`);
+        }
+        safeGit(`fetch origin ${baseBranch}`, repoPath);
+        git(`checkout -b ${branchName} origin/${baseBranch}`, repoPath);
+        const lines = [`Created and switched to branch "${branchName}" from origin/${baseBranch}.`];
+        if (push) {
+            git(`push -u origin ${branchName}`, repoPath);
+            lines.push(`Pushed to origin/${branchName} and set upstream.`);
+        }
+        return text(lines.join('\n'));
+    }
+    catch (err) {
+        return text(`Error creating branch: ${err.message}`);
+    }
+}