@stubbedev/atlassian-mcp 0.0.1

package/dist/config.js

@@ -0,0 +1,54 @@
+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 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 },
+    };
+}

package/dist/context.js

@@ -0,0 +1,98 @@
+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 '';
+    }
+}
+/**
+ * Unified developer context: git state + linked Jira issues + open PR for current branch.
+ */
+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)';
+    sections.push([
+        `Repository: ${repoPath}`,
+        `Branch:     ${branch}`,
+        `Remote:     ${remote}`,
+        '',
+        'Recent commits:',
+        recentCommits,
+        '',
+        'Working tree:',
+        status,
+    ].join('\n'));
+    // Jira — fetch any tickets referenced in the branch name
+    const jiraKeys = [...new Set(branch.match(JIRA_KEY_RE) ?? [])];
+    for (const key of jiraKeys) {
+        try {
+            const result = await jira.getIssue({ issueKey: key });
+            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);
+    if (parsed) {
+        try {
+            const pr = await bitbucket.findOpenPrForBranch(parsed.projectKey, parsed.repoSlug, branch);
+            if (pr) {
+                const reviewers = pr.reviewers.map((r) => `${r.user.displayName}${r.approved ? ' ✓' : ''}`).join(', ');
+                const url = pr.links?.self?.[0]?.href ?? '';
+                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'}`,
+                ];
+                if (url)
+                    prLines.push(`URL:       ${url}`);
+                sections.push(prLines.join('\n'));
+            }
+            else {
+                sections.push(`── Bitbucket (${parsed.projectKey}/${parsed.repoSlug}) ── No open PR for branch "${branch}"`);
+            }
+        }
+        catch {
+            sections.push(`── Bitbucket (${parsed.projectKey}/${parsed.repoSlug}) ── (could not fetch PRs)`);
+        }
+    }
+    return { content: [{ type: 'text', text: sections.join('\n\n') }] };
+}
+/**
+ * Creates a Bitbucket PR using the current git repo to auto-detect project, repo, and branch.
+ */
+export async function createPrFromContext(args, bitbucket) {
+    const repoPath = args.repoPath ?? process.cwd();
+    const remote = safeExec('git remote get-url origin', repoPath);
+    if (!remote)
+        throw new Error('No git remote found — are you in a git repository?');
+    const parsed = parseBitbucketRemote(remote);
+    if (!parsed)
+        throw new Error(`Could not parse Bitbucket project/repo from remote: ${remote}`);
+    const branch = safeExec('git rev-parse --abbrev-ref HEAD', repoPath);
+    if (!branch)
+        throw new Error('Could not determine current branch.');
+    if (branch === 'HEAD')
+        throw new Error('Detached HEAD state — check out a branch first.');
+    return bitbucket.createPullRequest({
+        projectKey: parsed.projectKey,
+        repoSlug: parsed.repoSlug,
+        title: args.title,
+        description: args.description,
+        fromBranch: branch,
+        toBranch: args.toBranch,
+        reviewers: args.reviewers,
+    });
+}

package/dist/git.js

@@ -0,0 +1,86 @@
+import { execSync } from 'child_process';
+const JIRA_KEY_RE = /\b[A-Z][A-Z0-9]+-\d+\b/g;
+function text(t) {
+    return { content: [{ type: 'text', text: t }] };
+}
+function git(cmd, cwd) {
+    return execSync(`git ${cmd}`, { cwd, encoding: 'utf-8' }).trim();
+}
+function safeGit(cmd, cwd, fallback = '') {
+    try {
+        return git(cmd, cwd);
+    }
+    catch {
+        return fallback;
+    }
+}
+export function getContext(args) {
+    const repoPath = args.repoPath ?? process.cwd();
+    const limit = args.commitLimit ?? 10;
+    try {
+        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, '');
+        const jiraKeys = [...new Set(branch.match(JIRA_KEY_RE) ?? [])];
+        const lines = [
+            `Repository: ${repoPath}`,
+            `Branch:     ${branch}`,
+            `Remote:     ${remote}`,
+        ];
+        if (jiraKeys.length > 0) {
+            lines.push(`Jira issue(s) detected in branch: ${jiraKeys.join(', ')}`);
+        }
+        lines.push('', `Recent commits (last ${limit}):`, commits || '(none)', '', 'Working tree status:', status || '(clean)');
+        return text(lines.join('\n'));
+    }
+    catch (err) {
+        return text(`Error reading git context: ${err.message}`);
+    }
+}
+export function getCommits(args) {
+    const repoPath = args.repoPath ?? process.cwd();
+    const limit = args.limit ?? 20;
+    const branch = args.branch ?? '';
+    try {
+        const format = '%H|%an|%ad|%s';
+        const cmd = `log --pretty=format:"${format}" --date=short -${limit}${branch ? ` ${branch}` : ''}`;
+        const raw = safeGit(cmd, repoPath, '');
+        if (!raw)
+            return text('No commits found.');
+        const lines = raw.split('\n').map((line) => {
+            const [hash, author, date, ...msgParts] = line.replace(/^"|"$/g, '').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();
+    const MAX_CHARS = 8000;
+    try {
+        let cmd;
+        if (args.fromRef && args.toRef) {
+            cmd = `diff ${args.fromRef} ${args.toRef}`;
+        }
+        else if (args.fromRef) {
+            cmd = `diff ${args.fromRef}`;
+        }
+        else {
+            cmd = 'diff HEAD';
+        }
+        const diff = safeGit(cmd, repoPath, '');
+        if (!diff)
+            return text('No differences found.');
+        if (diff.length > MAX_CHARS) {
+            return text(diff.slice(0, MAX_CHARS) + `\n\n... (truncated, ${diff.length - MAX_CHARS} more chars)`);
+        }
+        return text(diff);
+    }
+    catch (err) {
+        return text(`Error reading diff: ${err.message}`);
+    }
+}