@ama-work/mcp-atlassian 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ask-Me-Anything-dot-work
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,110 @@
+# ama-mcp-atlassian
+
+Standalone TypeScript MCP server wrapping the Atlassian REST API (Jira + Confluence). Works standalone via env vars or registry-integrated via [ama-mcp-registry](https://github.com/Ask-Me-Anything-dot-work/ama-mcp-registry).
+
+## Install
+
+```bash
+npm install -g @ama-work/mcp-atlassian
+# or
+bunx @ama-work/mcp-atlassian
+```
+
+## Usage
+
+### Claude Desktop
+
+Add to your `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "atlassian": {
+      "command": "bunx",
+      "args": ["@ama-work/mcp-atlassian"],
+      "env": {
+        "ATLASSIAN_ACCESS_TOKEN": "your-oauth-access-token",
+        "ATLASSIAN_CLOUD_ID": "your-atlassian-cloud-id"
+      }
+    }
+  }
+}
+```
+
+### Standalone mode
+
+Provide an Atlassian OAuth access token and your cloud ID directly:
+
+```json
+{
+  "mcpServers": {
+    "atlassian": {
+      "command": "bunx",
+      "args": ["@ama-work/mcp-atlassian"],
+      "env": {
+        "ATLASSIAN_ACCESS_TOKEN": "your-oauth-access-token",
+        "ATLASSIAN_CLOUD_ID": "your-atlassian-cloud-id"
+      }
+    }
+  }
+}
+```
+
+### Registry-integrated mode
+
+If you run [ama-mcp-registry](https://github.com/Ask-Me-Anything-dot-work/ama-mcp-registry), the server fetches its token automatically:
+
+```json
+{
+  "mcpServers": {
+    "atlassian": {
+      "command": "bunx",
+      "args": ["@ama-work/mcp-atlassian"],
+      "env": {
+        "REGISTRY_URL": "https://your-registry.example.com",
+        "INSTANCE_ID": "your-instance-id",
+        "GATEWAY_PSK": "your-pre-shared-key"
+      }
+    }
+  }
+}
+```
+
+The token is cached and proactively refreshed 5 minutes before expiry.
+
+## MCP Registry Integration
+
+Import the canonical definition via URL:
+
+```
+https://raw.githubusercontent.com/Ask-Me-Anything-dot-work/ama-mcp-atlassian/main/definitions/atlassian.json
+```
+
+### OAuth Setup
+
+Before using this server, register an OAuth 2.0 app at [developer.atlassian.com](https://developer.atlassian.com):
+
+1. Create a new OAuth 2.0 app
+2. Add the required scopes (see `definitions/atlassian.json`)
+3. Copy the **Client ID** and replace `YOUR_ATLASSIAN_CLIENT_ID` in the definition
+4. Generate an access token with the required scopes
+
+## Tools
+
+**Jira:** `jira_search_issues`, `jira_get_issue`, `jira_create_issue`, `jira_update_issue`, `jira_transition_issue`, `jira_add_comment`, `jira_get_projects`
+
+**Confluence:** `confluence_search`, `confluence_get_page`, `confluence_create_page`, `confluence_update_page`, `confluence_add_comment`, `confluence_get_spaces`
+
+**Meta:** `atlassian_whoami`
+
+## Development
+
+```bash
+bash bootstrap.sh
+bun run typecheck
+bun run lint
+```
+
+## License
+
+MIT

package/dist/client/adf.d.ts

@@ -0,0 +1,17 @@
+interface AdfNode {
+    type: string;
+    content?: AdfNode[];
+    text?: string;
+    marks?: Array<{
+        type: string;
+    }>;
+    attrs?: Record<string, unknown>;
+}
+interface AdfDoc {
+    version: number;
+    type: "doc";
+    content: AdfNode[];
+}
+export declare function toADF(markdown: string): AdfDoc;
+export declare function fromADF(doc: AdfDoc | AdfNode): string;
+export {};

package/dist/client/adf.js

@@ -0,0 +1,137 @@
+function parseInline(text) {
+    const nodes = [];
+    const pattern = /(\*\*\*(.+?)\*\*\*|\*\*(.+?)\*\*|\*(.+?)\*|`(.+?)`)/g;
+    let last = 0;
+    let m;
+    while ((m = pattern.exec(text)) !== null) {
+        if (m.index > last) {
+            nodes.push({ type: "text", text: text.slice(last, m.index) });
+        }
+        nodes.push(parseInlineMatch(m));
+        last = m.index + m[0].length;
+    }
+    if (last < text.length) {
+        nodes.push({ type: "text", text: text.slice(last) });
+    }
+    return nodes.length ? nodes : [{ type: "text", text }];
+}
+function parseInlineMatch(m) {
+    if (m[2])
+        return { type: "text", text: m[2], marks: [{ type: "strong" }, { type: "em" }] };
+    if (m[3])
+        return { type: "text", text: m[3], marks: [{ type: "strong" }] };
+    if (m[4])
+        return { type: "text", text: m[4], marks: [{ type: "em" }] };
+    return { type: "text", text: m[5], marks: [{ type: "code" }] };
+}
+function parseCodeBlock(lines, start) {
+    const lang = lines[start].slice(3).trim();
+    const codeLines = [];
+    let i = start + 1;
+    while (i < lines.length && !lines[i].startsWith("```")) {
+        codeLines.push(lines[i]);
+        i++;
+    }
+    const node = { type: "codeBlock", content: [{ type: "text", text: codeLines.join("\n") }] };
+    if (lang)
+        node.attrs = { language: lang };
+    return { node, next: i + 1 };
+}
+function parseBulletList(lines, start) {
+    const items = [];
+    let i = start;
+    while (i < lines.length && lines[i].match(/^[-*]\s+/)) {
+        const itemText = lines[i].replace(/^[-*]\s+/, "");
+        items.push({ type: "listItem", content: [{ type: "paragraph", content: parseInline(itemText) }] });
+        i++;
+    }
+    return { node: { type: "bulletList", content: items }, next: i };
+}
+export function toADF(markdown) {
+    const lines = markdown.split("\n");
+    const content = [];
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        if (line.startsWith("```")) {
+            const result = parseCodeBlock(lines, i);
+            content.push(result.node);
+            i = result.next;
+            continue;
+        }
+        const headingMatch = line.match(/^(#{1,6})\s+(.+)/);
+        if (headingMatch) {
+            content.push({
+                type: "heading",
+                attrs: { level: headingMatch[1].length },
+                content: parseInline(headingMatch[2]),
+            });
+            i++;
+            continue;
+        }
+        if (line.match(/^[-*]\s+/)) {
+            const result = parseBulletList(lines, i);
+            content.push(result.node);
+            i = result.next;
+            continue;
+        }
+        if (line.trim() !== "") {
+            content.push({ type: "paragraph", content: parseInline(line) });
+        }
+        i++;
+    }
+    return { version: 1, type: "doc", content };
+}
+function renderMarks(text, marks) {
+    if (!marks?.length)
+        return text;
+    let result = text;
+    for (const mark of marks) {
+        if (mark.type === "strong")
+            result = `**${result}**`;
+        else if (mark.type === "em")
+            result = `*${result}*`;
+        else if (mark.type === "code")
+            result = `\`${result}\``;
+    }
+    return result;
+}
+function renderTextNode(node) {
+    return renderMarks(node.text ?? "", node.marks);
+}
+function renderCodeBlock(node) {
+    const lang = node.attrs?.language ?? "";
+    const code = (node.content ?? []).map(renderNode).join("");
+    return `\`\`\`${lang}\n${code}\n\`\`\`\n`;
+}
+function renderHeading(node) {
+    const level = node.attrs?.level ?? 1;
+    return `${"#".repeat(level)} ${(node.content ?? []).map(renderNode).join("")}\n`;
+}
+function renderListItem(node) {
+    return (node.content ?? []).map(renderNode).join("");
+}
+function renderNode(node) {
+    switch (node.type) {
+        case "text":
+            return renderTextNode(node);
+        case "paragraph":
+            return (node.content ?? []).map(renderNode).join("") + "\n";
+        case "heading":
+            return renderHeading(node);
+        case "bulletList":
+            return (node.content ?? []).map((item) => `- ${renderNode(item)}`).join("");
+        case "listItem":
+            return renderListItem(node);
+        case "codeBlock":
+            return renderCodeBlock(node);
+        default:
+            return (node.content ?? []).map(renderNode).join("");
+    }
+}
+export function fromADF(doc) {
+    if (doc.type === "doc") {
+        return (doc.content ?? []).map(renderNode).join("");
+    }
+    return renderNode(doc);
+}