devto-mcp 0.5.0 → 0.5.2

package/dist/tools.js

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -17,10 +50,57 @@ exports.listEpics = listEpics;
 exports.updateEpic = updateEpic;
 exports.getEpic = getEpic;
 exports.deleteComment = deleteComment;
+exports.addCommentTool = addCommentTool;
+exports.deleteIssueTool = deleteIssueTool;
+exports.listSprints = listSprints;
+exports.createSprintTool = createSprintTool;
+exports.moveToSprintTool = moveToSprintTool;
+exports.manageSprintTool = manageSprintTool;
 exports.getStatus = getStatus;
+exports.searchIssues = searchIssues;
+exports.getCustomFields = getCustomFields;
+exports.linkIssues = linkIssues;
+exports.getIssueLinks = getIssueLinks;
+exports.getLinkTypes = getLinkTypes;
+exports.logWork = logWork;
+exports.getWorklog = getWorklog;
+exports.setEstimate = setEstimate;
+exports.listVersions = listVersions;
+exports.createVersion = createVersion;
+exports.releaseVersion = releaseVersion;
+exports.getBacklog = getBacklog;
+exports.moveToBacklog = moveToBacklog;
+exports.bulkCreateTasks = bulkCreateTasks;
+exports.bulkUpdateTasks = bulkUpdateTasks;
+exports.attachFile = attachFile;
+exports.listAttachments = listAttachments;
+exports.manageWatchers = manageWatchers;
 const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
 const client_1 = require("./client");
 const config_1 = require("./config");
+// ─── Content sanitization (prompt injection defense) ─────────────────────────
+/**
+ * Wrap user-authored content from Jira in boundary markers so the LLM
+ * knows it's untrusted external content, not system instructions.
+ */
+function sanitizeUserContent(text) {
+    if (!text)
+        return text;
+    // Strip common prompt injection patterns
+    const cleaned = text
+        .replace(/ignore (?:all )?previous instructions/gi, "[filtered]")
+        .replace(/you are now/gi, "[filtered]")
+        .replace(/system:\s/gi, "[filtered] ");
+    return cleaned;
+}
+/**
+ * Sanitize a task title from Jira (lightweight — just strips injection patterns).
+ */
+function sanitizeTitle(title) {
+    return sanitizeUserContent(title);
+}
 // ─── Anthropic system prompt ────────────────────────────────────────────────
 const PLAN_SYSTEM_PROMPT = `You are DevTo, an AI work manager for software developers. Your job is to take a feature description and break it into a structured development plan. Always return a JSON object with this exact structure and nothing else — no preamble, no markdown, just the JSON:
 {
@@ -91,12 +171,15 @@ function scoreMatch(query, task) {
  *   { resolved: false, prompt: string } — disambiguation needed
  */
 async function resolveIssueKey(input) {
+    if (!input || typeof input !== "string") {
+        return { resolved: false, prompt: "No issue key provided. Please specify a ticket key (e.g. PROJ-5) or describe the task." };
+    }
     // If it already looks like a valid issue key, pass through
     if (ISSUE_KEY_PATTERN.test(input.trim().toUpperCase())) {
         return { resolved: true, key: input.trim().toUpperCase() };
     }
-    // Fetch all open tasks for matching
-    const res = await (0, client_1.callApi)("GET", "/api/v1/tasks");
+    // Fetch all tasks (including done/in-review) for matching
+    const res = await (0, client_1.callApi)("GET", "/api/v1/tasks?all=true");
     if (res.total === 0) {
         return {
             resolved: false,
@@ -251,7 +334,7 @@ async function createEpic(title, description) {
     const res = await (0, client_1.callApi)("POST", "/api/v1/epic", { title, description });
     return `Done. I've tracked that as **${res.key}**.\n${res.url}`;
 }
-async function createTask(title, description, epicKey) {
+async function createTask(title, description, epicKey, issueType) {
     let resolvedEpicKey = epicKey;
     // Resolve ambiguous epic references
     if (epicKey) {
@@ -261,12 +344,11 @@ async function createTask(title, description, epicKey) {
         }
         resolvedEpicKey = resolved.key;
     }
-    const res = await (0, client_1.callApi)("POST", "/api/v1/task", {
-        title,
-        description,
-        epic_key: resolvedEpicKey,
-    });
-    return `Done. I've tracked that as **${res.key}**.\n${res.url}`;
+    const body = { title, description, epic_key: resolvedEpicKey };
+    if (issueType)
+        body.type = issueType;
+    const res = await (0, client_1.callApi)("POST", "/api/v1/task", body);
+    return `Done. I've tracked that as **${res.key}** (${issueType ?? "Story"}).\n${res.url}`;
 }
 async function createSubtask(title, description, parentKey) {
     // Resolve ambiguous parent references
@@ -303,32 +385,65 @@ async function getTasks(epicKey) {
         ``,
     ];
     res.tasks.forEach((task) => {
-        lines.push(`**${task.key}** — ${task.title}`);
+        lines.push(`**${task.key}** — ${sanitizeTitle(task.title)}`);
         lines.push(`  Status: ${task.status} | Type: ${task.type}${task.assignee ? ` | Assignee: ${task.assignee}` : ""}`);
         if (task.parent)
-            lines.push(`  Parent: ${task.parent.key} — ${task.parent.title}`);
+            lines.push(`  Parent: ${task.parent.key} — ${sanitizeTitle(task.parent.title)}`);
         lines.push(`  ${task.url}`);
         lines.push(``);
     });
     return lines.join("\n");
 }
-async function updateTask(issueKey, status, comment) {
+async function updateTask(issueKey, status, comment, assignee, priority, labels, epicKey, title, description) {
     // Resolve ambiguous references
     const resolved = await resolveIssueKey(issueKey);
     if (!resolved.resolved) {
         return resolved.prompt;
     }
+    // Resolve epic key if provided
+    let resolvedEpicKey;
+    if (epicKey) {
+        const epicResolved = await resolveIssueKey(epicKey);
+        if (!epicResolved.resolved) {
+            return epicResolved.prompt;
+        }
+        resolvedEpicKey = epicResolved.key;
+    }
     const body = {};
     if (status)
         body.status = status;
     if (comment)
         body.comment = comment;
+    if (assignee)
+        body.assignee = assignee;
+    if (priority)
+        body.priority = priority;
+    if (labels)
+        body.labels = labels;
+    if (resolvedEpicKey)
+        body.epic_key = resolvedEpicKey;
+    if (title)
+        body.title = title;
+    if (description)
+        body.description = description;
     const res = await (0, client_1.callApi)("PUT", `/api/v1/task/${resolved.key}`, body);
     const parts = [];
+    if (title)
+        parts.push(`Renamed **${resolved.key}** to "${title}".`);
+    if (description)
+        parts.push(`Updated description for **${resolved.key}**.`);
     if (status)
         parts.push(`Moved **${resolved.key}** to \`${status}\`.`);
     if (res.comment)
         parts.push(`Comment added to **${resolved.key}**.`);
+    if (assignee)
+        parts.push(`Assigned **${resolved.key}** to ${assignee}.`);
+    if (priority)
+        parts.push(`Set priority to ${priority}.`);
+    if (labels)
+        parts.push(`Labels set: ${labels.join(", ")}.`);
+    if (resolvedEpicKey)
+        parts.push(`Linked **${resolved.key}** to epic **${resolvedEpicKey}**.`);
     if (parts.length === 0)
         parts.push(`Updated **${resolved.key}**.`);
     return parts.join(" ");
@@ -349,7 +464,7 @@ async function getComments(issueKey) {
     res.comments.forEach((c) => {
         const date = new Date(c.created).toLocaleDateString();
         lines.push(`**${c.author}** (${date}):`);
-        lines.push(c.body);
+        lines.push(sanitizeUserContent(c.body));
         lines.push(``);
     });
     return lines.join("\n");
@@ -375,11 +490,11 @@ async function getProjectSummary() {
     }
     lines.push(`### Active Tasks`);
     res.issues.forEach((issue) => {
-        const parts = [`**${issue.key}** — ${issue.title} (${issue.status})`];
+        const parts = [`**${issue.key}** — ${sanitizeTitle(issue.title)} (${issue.status})`];
         if (issue.assignee)
             parts.push(`  Assignee: ${issue.assignee}`);
         if (issue.parent_key)
-            parts.push(`  Parent: ${issue.parent_key}${issue.epic_name ? ` — ${issue.epic_name}` : ""}`);
+            parts.push(`  Parent: ${issue.parent_key}${issue.epic_name ? ` — ${sanitizeTitle(issue.epic_name)}` : ""}`);
         lines.push(parts.join("\n"));
         lines.push(``);
     });
@@ -487,6 +602,94 @@ async function deleteComment(issueKey, commentId) {
     await (0, client_1.callApi)("DELETE", `/api/v1/issues/${resolved.key}/comments/${commentId}`);
     return `Comment \`${commentId}\` deleted from **${resolved.key}**.`;
 }
+// ─── Comment, delete, and sprint tools ────────────────────────────────────────
+async function addCommentTool(issueKey, comment) {
+    const resolved = await resolveIssueKey(issueKey);
+    if (!resolved.resolved) {
+        return resolved.prompt;
+    }
+    const res = await (0, client_1.callApi)("PUT", `/api/v1/task/${resolved.key}`, { comment });
+    return res.comment
+        ? `Comment added to **${resolved.key}**.`
+        : `Updated **${resolved.key}** (comment may have been added).`;
+}
+async function deleteIssueTool(issueKey) {
+    const resolved = await resolveIssueKey(issueKey);
+    if (!resolved.resolved) {
+        return resolved.prompt;
+    }
+    await (0, client_1.callApi)("DELETE", `/api/v1/issue/${resolved.key}`);
+    return `**${resolved.key}** has been permanently deleted.`;
+}
+async function listSprints() {
+    const res = await (0, client_1.callApi)("GET", "/api/v1/sprints");
+    if (res.total === 0) {
+        return "No active or upcoming sprints found. Use `create_sprint` to create one.";
+    }
+    const lines = [`## Sprints (${res.total})`, ``];
+    res.sprints.forEach((s) => {
+        const dates = s.start_date && s.end_date
+            ? ` (${new Date(s.start_date).toLocaleDateString()} — ${new Date(s.end_date).toLocaleDateString()})`
+            : "";
+        lines.push(`**${s.name}** — ${s.state}${dates}`);
+        lines.push(`  ID: ${s.id}`);
+        lines.push(``);
+    });
+    return lines.join("\n");
+}
+async function createSprintTool(name, startDate, endDate) {
+    const body = { name };
+    if (startDate)
+        body.start_date = startDate;
+    if (endDate)
+        body.end_date = endDate;
+    const res = await (0, client_1.callApi)("POST", "/api/v1/sprints", body);
+    return `Sprint **${res.sprint.name}** created (ID: ${res.sprint.id}, state: ${res.sprint.state}).`;
+}
+async function moveToSprintTool(sprintId, issueKeys) {
+    // Resolve issue keys semantically
+    const resolvedKeys = [];
+    for (const key of issueKeys) {
+        const resolved = await resolveIssueKey(key);
+        if (!resolved.resolved) {
+            return resolved.prompt;
+        }
+        resolvedKeys.push(resolved.key);
+    }
+    // Resolve sprint by name if not numeric
+    let numericSprintId = parseInt(sprintId, 10);
+    if (isNaN(numericSprintId)) {
+        // Fetch sprints and match by name
+        const sprints = await (0, client_1.callApi)("GET", "/api/v1/sprints");
+        const match = sprints.sprints.find((s) => s.name.toLowerCase().includes(sprintId.toLowerCase()));
+        if (!match) {
+            return `No sprint found matching "${sprintId}". Use \`list_sprints\` to see available sprints.`;
+        }
+        numericSprintId = match.id;
+    }
+    await (0, client_1.callApi)("POST", `/api/v1/sprints/${numericSprintId}/issues`, {
+        issue_keys: resolvedKeys,
+    });
+    return `Moved **${resolvedKeys.join(", ")}** to sprint ${numericSprintId}.`;
+}
+async function manageSprintTool(sprintId, action) {
+    // Resolve sprint by name if not numeric
+    let numericSprintId = parseInt(sprintId, 10);
+    if (isNaN(numericSprintId)) {
+        const sprints = await (0, client_1.callApi)("GET", "/api/v1/sprints");
+        const match = sprints.sprints.find((s) => s.name.toLowerCase().includes(sprintId.toLowerCase()));
+        if (!match) {
+            return `No sprint found matching "${sprintId}". Use \`list_sprints\` to see available sprints.`;
+        }
+        numericSprintId = match.id;
+    }
+    const state = action === "start" ? "active" : action === "close" ? "closed" : null;
+    if (!state) {
+        return `Invalid action "${action}". Use "start" or "close".`;
+    }
+    await (0, client_1.callApi)("PUT", `/api/v1/sprints/${numericSprintId}`, { state });
+    return `Sprint ${numericSprintId} is now **${state}**.`;
+}
 async function getStatus() {
     const res = await (0, client_1.callApi)("GET", "/api/v1/status");
     const lines = [
@@ -502,6 +705,387 @@ async function getStatus() {
     if (res.current_sprint) {
         lines.push(``, `**Current Sprint:** ${res.current_sprint}`);
     }
+    if (res.available_issue_types && res.available_issue_types.length > 0) {
+        lines.push(``, `**Available Issue Types:** ${res.available_issue_types.join(", ")}`);
+    }
     return lines.join("\n");
 }
+async function searchIssues(jql, maxResults) {
+    const res = await (0, client_1.callApi)("POST", "/api/v1/search", {
+        jql,
+        max_results: maxResults ?? 50,
+    });
+    if (res.total === 0) {
+        return `No issues found matching JQL: \`${jql}\``;
+    }
+    const lines = [
+        `## Search Results (${res.total} total)`,
+        ``,
+        `| Key | Title | Status | Type | Assignee |`,
+        `|-----|-------|--------|------|----------|`,
+    ];
+    res.issues.forEach((issue) => {
+        lines.push(`| ${issue.key} | ${issue.title} | ${issue.status} | ${issue.type} | ${issue.assignee ?? "—"} |`);
+    });
+    if (res.total > res.issues.length) {
+        lines.push(``, `_Showing ${res.issues.length} of ${res.total}. Refine your JQL for more specific results._`);
+    }
+    return lines.join("\n");
+}
+async function getCustomFields() {
+    const res = await (0, client_1.callApi)("GET", "/api/v1/fields");
+    if (res.total === 0) {
+        return "No custom fields found in the project.";
+    }
+    const lines = [
+        `## Custom Fields (${res.total})`,
+        ``,
+        `| ID | Name | Type | Required |`,
+        `|----|------|------|----------|`,
+    ];
+    res.fields.forEach((field) => {
+        lines.push(`| ${field.id} | ${field.name} | ${field.type} | ${field.required ? "Yes" : "No"} |`);
+    });
+    return lines.join("\n");
+}
+// ─── Issue Linking ────────────────────────────────────────────────────────────
+async function linkIssues(issueKey1, issueKey2, linkType) {
+    const resolved1 = await resolveIssueKey(issueKey1);
+    if (!resolved1.resolved) {
+        return resolved1.prompt;
+    }
+    const resolved2 = await resolveIssueKey(issueKey2);
+    if (!resolved2.resolved) {
+        return resolved2.prompt;
+    }
+    await (0, client_1.callApi)("POST", "/api/v1/issues/link", {
+        inward_key: resolved1.key,
+        outward_key: resolved2.key,
+        link_type: linkType,
+    });
+    return `Linked **${resolved1.key}** → **${resolved2.key}** (${linkType}).`;
+}
+async function getIssueLinks(issueKey) {
+    const resolved = await resolveIssueKey(issueKey);
+    if (!resolved.resolved) {
+        return resolved.prompt;
+    }
+    const res = await (0, client_1.callApi)("GET", `/api/v1/issues/${resolved.key}/links`);
+    if (res.total === 0) {
+        return `No links found on **${resolved.key}**.`;
+    }
+    const lines = [
+        `## Links on ${resolved.key} (${res.total})`,
+        ``,
+    ];
+    res.links.forEach((link) => {
+        if (link.inwardIssue) {
+            lines.push(`- **${link.type}** ← ${link.inwardIssue.key} — ${link.inwardIssue.title} (${link.inwardIssue.status})`);
+        }
+        if (link.outwardIssue) {
+            lines.push(`- **${link.type}** → ${link.outwardIssue.key} — ${link.outwardIssue.title} (${link.outwardIssue.status})`);
+        }
+    });
+    return lines.join("\n");
+}
+async function getLinkTypes() {
+    const res = await (0, client_1.callApi)("GET", "/api/v1/issues/link-types");
+    if (res.total === 0) {
+        return "No link types available.";
+    }
+    const lines = [
+        `## Link Types (${res.total})`,
+        ``,
+        `| Name | Inward | Outward |`,
+        `|------|--------|---------|`,
+    ];
+    res.link_types.forEach((lt) => {
+        lines.push(`| ${lt.name} | ${lt.inward} | ${lt.outward} |`);
+    });
+    return lines.join("\n");
+}
+async function logWork(issueKey, timeSpent, comment) {
+    const resolved = await resolveIssueKey(issueKey);
+    if (!resolved.resolved) {
+        return resolved.prompt;
+    }
+    const body = { time_spent: timeSpent };
+    if (comment)
+        body.comment = comment;
+    await (0, client_1.callApi)("POST", `/api/v1/issues/${resolved.key}/worklog`, body);
+    return `Logged **${timeSpent}** on **${resolved.key}**.${comment ? ` Comment: "${comment}"` : ""}`;
+}
+async function getWorklog(issueKey) {
+    const resolved = await resolveIssueKey(issueKey);
+    if (!resolved.resolved) {
+        return resolved.prompt;
+    }
+    const res = await (0, client_1.callApi)("GET", `/api/v1/issues/${resolved.key}/worklog`);
+    if (res.total === 0) {
+        return `No work logged on **${resolved.key}**.`;
+    }
+    const lines = [
+        `## Work Log — ${resolved.key} (${res.total} entries)`,
+        ``,
+    ];
+    res.worklogs.forEach((entry) => {
+        const date = new Date(entry.started).toLocaleDateString();
+        lines.push(`**${entry.author}** — ${entry.time_spent} (${date})`);
+        if (entry.comment)
+            lines.push(`  ${entry.comment}`);
+        lines.push(``);
+    });
+    return lines.join("\n");
+}
+async function setEstimate(issueKey, estimate) {
+    const resolved = await resolveIssueKey(issueKey);
+    if (!resolved.resolved) {
+        return resolved.prompt;
+    }
+    await (0, client_1.callApi)("PUT", `/api/v1/issues/${resolved.key}/time`, {
+        original_estimate: estimate,
+    });
+    return `Set estimate for **${resolved.key}** to **${estimate}**.`;
+}
+async function listVersions() {
+    const res = await (0, client_1.callApi)("GET", "/api/v1/versions");
+    if (res.total === 0) {
+        return "No versions found in the project. Use `create_version` to create one.";
+    }
+    const lines = [
+        `## Versions (${res.total})`,
+        ``,
+    ];
+    res.versions.forEach((v) => {
+        const status = v.released ? "Released" : "Unreleased";
+        const date = v.release_date ? ` (${v.release_date})` : "";
+        lines.push(`**${v.name}** — ${status}${date}`);
+        if (v.description)
+            lines.push(`  ${v.description}`);
+        lines.push(``);
+    });
+    return lines.join("\n");
+}
+async function createVersion(name, description, releaseDate) {
+    const body = { name };
+    if (description)
+        body.description = description;
+    if (releaseDate)
+        body.release_date = releaseDate;
+    const res = await (0, client_1.callApi)("POST", "/api/v1/versions", body);
+    return `Version **${res.name}** created (ID: ${res.id}).`;
+}
+async function releaseVersion(versionName) {
+    // Find version by name
+    const versions = await (0, client_1.callApi)("GET", "/api/v1/versions");
+    const match = versions.versions.find((v) => v.name.toLowerCase() === versionName.toLowerCase() || v.id === versionName);
+    if (!match) {
+        return `No version found matching "${versionName}". Use \`list_versions\` to see available versions.`;
+    }
+    if (match.released) {
+        return `Version **${match.name}** is already released.`;
+    }
+    await (0, client_1.callApi)("PUT", `/api/v1/versions/${match.id}`, {
+        released: true,
+        release_date: new Date().toISOString().split("T")[0],
+    });
+    return `Version **${match.name}** marked as released.`;
+}
+async function getBacklog() {
+    const res = await (0, client_1.callApi)("GET", "/api/v1/backlog");
+    if (res.total === 0) {
+        return "Backlog is empty — all issues are assigned to sprints.";
+    }
+    const lines = [
+        `## Backlog (${res.total} issues)`,
+        ``,
+    ];
+    res.issues.forEach((issue) => {
+        lines.push(`**${issue.key}** — ${issue.title}`);
+        lines.push(`  Status: ${issue.status} | Type: ${issue.type}${issue.assignee ? ` | Assignee: ${issue.assignee}` : ""}`);
+        if (issue.parent)
+            lines.push(`  Parent: ${issue.parent.key} — ${issue.parent.title}`);
+        lines.push(``);
+    });
+    return lines.join("\n");
+}
+async function moveToBacklog(issueKeys) {
+    const resolvedKeys = [];
+    for (const key of issueKeys) {
+        const resolved = await resolveIssueKey(key);
+        if (!resolved.resolved) {
+            return resolved.prompt;
+        }
+        resolvedKeys.push(resolved.key);
+    }
+    await (0, client_1.callApi)("POST", "/api/v1/backlog", {
+        issue_keys: resolvedKeys,
+    });
+    return `Moved **${resolvedKeys.join(", ")}** to backlog.`;
+}
+// ─── Bulk Operations ──────────────────────────────────────────────────────────
+async function bulkCreateTasks(tasks) {
+    const results = [];
+    for (const task of tasks) {
+        try {
+            const body = { title: task.title, description: task.description };
+            if (task.type)
+                body.type = task.type;
+            if (task.epic_key)
+                body.epic_key = task.epic_key;
+            const res = await (0, client_1.callApi)("POST", "/api/v1/task", body);
+            results.push({ key: res.key, title: task.title });
+        }
+        catch (err) {
+            results.push({
+                key: "FAILED",
+                title: task.title,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    const succeeded = results.filter((r) => r.key !== "FAILED");
+    const failed = results.filter((r) => r.key === "FAILED");
+    const lines = [
+        `## Bulk Create — ${succeeded.length}/${tasks.length} succeeded`,
+        ``,
+    ];
+    succeeded.forEach((r) => {
+        lines.push(`- **${r.key}** — ${r.title}`);
+    });
+    if (failed.length > 0) {
+        lines.push(``, `### Failed (${failed.length})`);
+        failed.forEach((r) => {
+            lines.push(`- ${r.title}: ${r.error}`);
+        });
+    }
+    return lines.join("\n");
+}
+async function bulkUpdateTasks(updates) {
+    const results = [];
+    for (const update of updates) {
+        const resolved = await resolveIssueKey(update.issue_key);
+        if (!resolved.resolved) {
+            results.push({ key: update.issue_key, success: false, error: "Could not resolve issue key" });
+            continue;
+        }
+        try {
+            const body = {};
+            if (update.status)
+                body.status = update.status;
+            if (update.comment)
+                body.comment = update.comment;
+            if (update.assignee)
+                body.assignee = update.assignee;
+            if (update.priority)
+                body.priority = update.priority;
+            await (0, client_1.callApi)("PUT", `/api/v1/task/${resolved.key}`, body);
+            results.push({ key: resolved.key, success: true });
+        }
+        catch (err) {
+            results.push({
+                key: resolved.key,
+                success: false,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    const succeeded = results.filter((r) => r.success);
+    const failed = results.filter((r) => !r.success);
+    const lines = [
+        `## Bulk Update — ${succeeded.length}/${updates.length} succeeded`,
+        ``,
+    ];
+    succeeded.forEach((r) => {
+        lines.push(`- **${r.key}** updated`);
+    });
+    if (failed.length > 0) {
+        lines.push(``, `### Failed (${failed.length})`);
+        failed.forEach((r) => {
+            lines.push(`- **${r.key}**: ${r.error}`);
+        });
+    }
+    return lines.join("\n");
+}
+async function attachFile(issueKey, filePath) {
+    const resolved = await resolveIssueKey(issueKey);
+    if (!resolved.resolved) {
+        return resolved.prompt;
+    }
+    // Read the file from the local filesystem
+    let fileBuffer;
+    try {
+        fileBuffer = fs.readFileSync(filePath);
+    }
+    catch (err) {
+        return `Could not read file at \`${filePath}\`: ${err instanceof Error ? err.message : String(err)}`;
+    }
+    const filename = path.basename(filePath);
+    const contentBase64 = fileBuffer.toString("base64");
+    await (0, client_1.callApi)("POST", `/api/v1/issues/${resolved.key}/attachments`, {
+        filename,
+        content_base64: contentBase64,
+    });
+    return `Attached **${filename}** to **${resolved.key}**.`;
+}
+async function listAttachments(issueKey) {
+    const resolved = await resolveIssueKey(issueKey);
+    if (!resolved.resolved) {
+        return resolved.prompt;
+    }
+    const res = await (0, client_1.callApi)("GET", `/api/v1/issues/${resolved.key}/attachments`);
+    if (res.total === 0) {
+        return `No attachments on **${resolved.key}**.`;
+    }
+    const lines = [
+        `## Attachments on ${resolved.key} (${res.total})`,
+        ``,
+    ];
+    res.attachments.forEach((a) => {
+        const size = a.size < 1024 ? `${a.size}B` : a.size < 1048576 ? `${Math.round(a.size / 1024)}KB` : `${(a.size / 1048576).toFixed(1)}MB`;
+        const date = new Date(a.created).toLocaleDateString();
+        lines.push(`- **${a.filename}** (${size}) — ${a.author}, ${date}`);
+    });
+    return lines.join("\n");
+}
+async function manageWatchers(issueKey, action, userName) {
+    const resolved = await resolveIssueKey(issueKey);
+    if (!resolved.resolved) {
+        return resolved.prompt;
+    }
+    switch (action) {
+        case "list": {
+            const res = await (0, client_1.callApi)("GET", `/api/v1/issues/${resolved.key}/watchers`);
+            if (res.total === 0) {
+                return `No watchers on **${resolved.key}**.`;
+            }
+            const lines = [
+                `## Watchers on ${resolved.key} (${res.total})`,
+                ``,
+            ];
+            res.watchers.forEach((w) => {
+                lines.push(`- ${w.display_name}`);
+            });
+            return lines.join("\n");
+        }
+        case "add": {
+            if (!userName) {
+                return `User name is required for the "add" action. Provide the display name of the person to add as a watcher.`;
+            }
+            await (0, client_1.callApi)("POST", `/api/v1/issues/${resolved.key}/watchers`, {
+                user_name: userName,
+            });
+            return `Added **${userName}** as watcher on **${resolved.key}**.`;
+        }
+        case "remove": {
+            if (!userName) {
+                return `User name is required for the "remove" action. Provide the display name of the person to remove as a watcher.`;
+            }
+            await (0, client_1.callApi)("DELETE", `/api/v1/issues/${resolved.key}/watchers?user_name=${encodeURIComponent(userName)}`);
+            return `Removed **${userName}** as watcher from **${resolved.key}**.`;
+        }
+        default:
+            return `Invalid action "${action}". Use "list", "add", or "remove".`;
+    }
+}
 //# sourceMappingURL=tools.js.map