@stubbedev/atlassian-mcp 0.4.5 → 0.5.0

package/dist/config.js

@@ -1,62 +0,0 @@
-import { readFileSync, existsSync } from 'fs';
-import { homedir } from 'os';
-import { join, resolve } from 'path';
-function readJsonFile(filePath) {
-    try {
-        if (!existsSync(filePath))
-            return null;
-        return JSON.parse(readFileSync(filePath, 'utf-8'));
-    }
-    catch {
-        return null;
-    }
-}
-function getConfigPath() {
-    const configArgIndex = process.argv.indexOf('--config');
-    if (configArgIndex !== -1 && process.argv[configArgIndex + 1]) {
-        return resolve(process.argv[configArgIndex + 1]);
-    }
-    if (process.env.ATLASSIAN_MCP_CONFIG) {
-        return resolve(process.env.ATLASSIAN_MCP_CONFIG);
-    }
-    const homeConfig = join(homedir(), '.atlassian-mcp.json');
-    if (existsSync(homeConfig))
-        return homeConfig;
-    const cwdConfig = join(process.cwd(), '.atlassian-mcp.json');
-    if (existsSync(cwdConfig))
-        return cwdConfig;
-    return null;
-}
-export function loadConfig() {
-    const configPath = getConfigPath();
-    const file = configPath ? readJsonFile(configPath) : null;
-    const jiraUrl = file?.jira?.url ?? process.env.JIRA_URL ?? '';
-    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 config = {};
-    if (jiraUrl && jiraToken) {
-        config.jira = { url: jiraUrl, token: jiraToken };
-    }
-    else if (jiraUrl || jiraToken) {
-        // Partially configured — log which piece is missing so the user can fix it
-        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 if (bitbucketUrl || bitbucketToken) {
-        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

@@ -1,162 +0,0 @@
-import { execSync } from 'child_process';
-import { parseBitbucketRemote } from './bitbucket.js';
-const JIRA_KEY_RE = /\b[A-Z][A-Z0-9]+-\d+\b/g;
-function safeExec(cmd, cwd) {
-    try {
-        return execSync(cmd, { cwd, encoding: 'utf-8' }).trim();
-    }
-    catch {
-        return '';
-    }
-}
-/** Top recent committers from the last `lookback` commits, ranked by count. */
-export function getTopCommitters(repoPath, lookback = 50, top = 5) {
-    const raw = safeExec(`git log -n ${lookback} --format=%aN%x09%aE`, repoPath);
-    if (!raw)
-        return [];
-    const counts = new Map();
-    for (const line of raw.split('\n')) {
-        const [name, email] = line.split('\t');
-        if (!name)
-            continue;
-        const key = (email || name).toLowerCase();
-        const existing = counts.get(key);
-        if (existing)
-            existing.commits++;
-        else
-            counts.set(key, { name, email: email ?? '', commits: 1 });
-    }
-    return [...counts.values()]
-        .sort((a, b) => b.commits - a.commits)
-        .slice(0, top);
-}
-/**
- * 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();
-    const sections = [];
-    const branch = safeExec('git rev-parse --abbrev-ref HEAD', repoPath) || '(unknown)';
-    const remote = safeExec('git remote get-url origin', repoPath) || '(no remote)';
-    const recentCommits = safeExec('git log --oneline -5', repoPath) || '(none)';
-    const status = safeExec('git status --short', repoPath) || '(clean)';
-    const committers = getTopCommitters(repoPath, 50, 5);
-    const parsed = bitbucket?.isRemoteForThisInstance(remote) ? parseBitbucketRemote(remote) : null;
-    // Upstream ahead/behind
-    const upstream = safeExec('git rev-parse --abbrev-ref @{u}', repoPath);
-    let upstreamLine = '';
-    if (upstream) {
-        const ab = safeExec(`git 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)'}`;
-        }
-    }
-    // Identity — best-effort, parallel
-    const [jiraMe, bbMe] = await Promise.all([
-        jira ? jira.whoami().catch(() => null) : Promise.resolve(null),
-        bitbucket ? bitbucket.whoami().catch(() => null) : Promise.resolve(null),
-    ]);
-    const youParts = [];
-    if (jiraMe)
-        youParts.push(`Jira ${jiraMe.name ?? jiraMe.key ?? '(unknown)'}${jiraMe.displayName ? ` "${jiraMe.displayName}"` : ''}`);
-    if (bbMe)
-        youParts.push(`Bitbucket ${bbMe}`);
-    const headerLines = [
-        `Repository: ${repoPath}`,
-        `Branch:     ${branch}`,
-        ...(upstreamLine ? [`Upstream:   ${upstreamLine}`] : []),
-        `Remote:     ${remote}`,
-        ...(parsed ? [`Bitbucket:  ${parsed.projectKey}/${parsed.repoSlug}`] : []),
-        ...(youParts.length ? [`You:        ${youParts.join(' · ')}`] : []),
-    ];
-    if (committers.length) {
-        headerLines.push('');
-        headerLines.push('Top recent committers (last 50):');
-        for (const c of committers) {
-            const ident = c.email ? `${c.name} <${c.email}>` : c.name;
-            headerLines.push(`  ${c.commits.toString().padStart(3)} — ${ident}`);
-        }
-        headerLines.push('  (look up usernames via jira_search resource=users / bitbucket_search resource=users — do NOT shell out to git/gh/bb)');
-    }
-    headerLines.push('');
-    headerLines.push('Recent commits:');
-    headerLines.push(recentCommits);
-    headerLines.push('');
-    headerLines.push('Working tree:');
-    headerLines.push(status);
-    sections.push(headerLines.join('\n'));
-    // Jira — fetch overview for any tickets referenced in the branch name (parallel)
-    const jiraKeys = jira ? [...new Set(branch.match(JIRA_KEY_RE) ?? [])] : [];
-    const jiraResults = await Promise.all(jiraKeys.map(async (key) => {
-        try {
-            const result = await jira.issueOverview({
-                issueKey: key,
-                includeComments: true,
-                commentsMaxResults: 5,
-                includeTransitions: true,
-                includeSprint: true,
-                descriptionMaxChars: 800,
-            });
-            return `── Jira ${key} ──\n${result.content[0].text}`;
-        }
-        catch {
-            return `── Jira ${key} ── (could not fetch)`;
-        }
-    }));
-    sections.push(...jiraResults);
-    // Bitbucket — find the open PR for this branch (only if remote points to this instance)
-    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'} (${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 {
-                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 {
-            sections.push(`── Bitbucket (${parsed.projectKey}/${parsed.repoSlug}) ── (could not fetch PRs)`);
-        }
-    }
-    return { content: [{ type: 'text', text: sections.join('\n\n') }] };
-}

package/dist/git.js

@@ -1,227 +0,0 @@
-import { execFileSync } from 'child_process';
-const JIRA_KEY_RE = /\b[A-Z][A-Z0-9]+-\d+\b/g;
-// Allowlist for git refs (commits, branches used as refs in diff commands)
-const SAFE_REF_RE = /^[a-zA-Z0-9/_.\-@{}~^:]+(\.\.\.[a-zA-Z0-9/_.\-@{}~^:]+)?$/;
-// Allowlist for branch names (stricter — no range syntax)
-const SAFE_BRANCH_RE = /^[a-zA-Z0-9/_.\-]+$/;
-function text(t) {
-    return { content: [{ type: 'text', text: t }] };
-}
-function git(args, cwd) {
-    return execFileSync('git', args, { cwd, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
-}
-function safeGit(args, cwd, fallback = '') {
-    try {
-        return git(args, cwd);
-    }
-    catch {
-        return fallback;
-    }
-}
-function validateRepoPath(repoPath) {
-    try {
-        execFileSync('git', ['rev-parse', '--git-dir'], { cwd: repoPath, encoding: 'utf-8', stdio: 'pipe' });
-    }
-    catch {
-        throw new Error(`Not a git repository: ${repoPath}`);
-    }
-}
-function validateBranch(branch, label) {
-    if (!SAFE_BRANCH_RE.test(branch)) {
-        throw new Error(`Invalid ${label} "${branch}". Use only letters, numbers, /, _, ., -`);
-    }
-}
-function validateRef(ref, label) {
-    if (!SAFE_REF_RE.test(ref)) {
-        throw new Error(`Invalid ${label} "${ref}". Use only safe git ref characters.`);
-    }
-}
-export function getContext(args) {
-    const repoPath = args.repoPath ?? process.cwd();
-    const limit = Math.max(1, Math.min(args.commitLimit ?? 10, 100));
-    try {
-        validateRepoPath(repoPath);
-        const branch = safeGit(['rev-parse', '--abbrev-ref', 'HEAD'], repoPath, '(unknown)');
-        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 (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);
-            }
-        }
-        return text(lines.join('\n'));
-    }
-    catch (err) {
-        return text(`Error reading git context: ${err.message}`);
-    }
-}
-// Not exposed as an MCP tool — internal/experimental use only
-export function getCommits(args) {
-    const repoPath = args.repoPath ?? process.cwd();
-    const limit = Math.max(1, Math.min(args.limit ?? 20, 200));
-    const branch = args.branch ?? '';
-    try {
-        validateRepoPath(repoPath);
-        if (branch)
-            validateBranch(branch, 'branch');
-        const format = '%H|%an|%ad|%s';
-        const gitArgs = ['log', `--pretty=format:${format}`, '--date=short', `-${limit}`, ...(branch ? [branch] : [])];
-        const raw = safeGit(gitArgs, repoPath, '');
-        if (!raw)
-            return text('No commits found.');
-        const lines = raw.split('\n').map((line) => {
-            const [hash, author, date, ...msgParts] = line.split('|');
-            return `${hash?.slice(0, 8)} ${date} ${author}: ${msgParts.join('|')}`;
-        });
-        return text(`Last ${lines.length} commit(s)${branch ? ` on ${branch}` : ''}:\n${lines.join('\n')}`);
-    }
-    catch (err) {
-        return text(`Error reading commits: ${err.message}`);
-    }
-}
-export function getDiff(args) {
-    const repoPath = args.repoPath ?? process.cwd();
-    try {
-        validateRepoPath(repoPath);
-        let gitArgs;
-        if (args.fromRef && args.toRef) {
-            validateRef(args.fromRef, 'fromRef');
-            validateRef(args.toRef, 'toRef');
-            gitArgs = ['diff', args.fromRef, args.toRef];
-        }
-        else if (args.fromRef) {
-            validateRef(args.fromRef, 'fromRef');
-            gitArgs = ['diff', args.fromRef];
-        }
-        else {
-            gitArgs = ['diff', 'HEAD'];
-        }
-        const diff = safeGit(gitArgs, repoPath, '');
-        if (!diff)
-            return text('No differences found.');
-        return text(diff);
-    }
-    catch (err) {
-        return text(`Error reading diff: ${err.message}`);
-    }
-}
-export function checkRemoteBranch(branchName, repoPath) {
-    validateBranch(branchName, 'branchName');
-    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 — failure is non-fatal (network/credentials issue)
-    try {
-        git(['fetch', 'origin', branchName], repoPath);
-    }
-    catch {
-        return { exists: true, sha: sha?.slice(0, 8) };
-    }
-    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 {
-        validateBranch(branchName, 'branchName');
-        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;
-    try {
-        validateRepoPath(repoPath);
-        if (!SAFE_BRANCH_RE.test(branchName)) {
-            return text(`Invalid branch name "${branchName}". Use only letters, numbers, /, _, ., -`);
-        }
-        const baseBranch = args.baseBranch ?? getDefaultBranch(repoPath);
-        if (!SAFE_BRANCH_RE.test(baseBranch)) {
-            return text(`Invalid base branch name "${baseBranch}". 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}`);
-    }
-}