mcp-jira-stdio 1.0.0

package/dist/index.js

@@ -0,0 +1,2227 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { ListToolsRequestSchema, CallToolRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import axios from 'axios';
+import { z } from 'zod';
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  __defProp(target, "default", { value: mod, enumerable: true }) ,
+  mod
+));
+
+// node_modules/dotenv/package.json
+var require_package = __commonJS({
+  "node_modules/dotenv/package.json"(exports, module) {
+    module.exports = {
+      name: "dotenv",
+      version: "17.2.1",
+      description: "Loads environment variables from .env file",
+      main: "lib/main.js",
+      types: "lib/main.d.ts",
+      exports: {
+        ".": {
+          types: "./lib/main.d.ts",
+          require: "./lib/main.js",
+          default: "./lib/main.js"
+        },
+        "./config": "./config.js",
+        "./config.js": "./config.js",
+        "./lib/env-options": "./lib/env-options.js",
+        "./lib/env-options.js": "./lib/env-options.js",
+        "./lib/cli-options": "./lib/cli-options.js",
+        "./lib/cli-options.js": "./lib/cli-options.js",
+        "./package.json": "./package.json"
+      },
+      scripts: {
+        "dts-check": "tsc --project tests/types/tsconfig.json",
+        lint: "standard",
+        pretest: "npm run lint && npm run dts-check",
+        test: "tap run --allow-empty-coverage --disable-coverage --timeout=60000",
+        "test:coverage": "tap run --show-full-coverage --timeout=60000 --coverage-report=text --coverage-report=lcov",
+        prerelease: "npm test",
+        release: "standard-version"
+      },
+      repository: {
+        type: "git",
+        url: "git://github.com/motdotla/dotenv.git"
+      },
+      homepage: "https://github.com/motdotla/dotenv#readme",
+      funding: "https://dotenvx.com",
+      keywords: [
+        "dotenv",
+        "env",
+        ".env",
+        "environment",
+        "variables",
+        "config",
+        "settings"
+      ],
+      readmeFilename: "README.md",
+      license: "BSD-2-Clause",
+      devDependencies: {
+        "@types/node": "^18.11.3",
+        decache: "^4.6.2",
+        sinon: "^14.0.1",
+        standard: "^17.0.0",
+        "standard-version": "^9.5.0",
+        tap: "^19.2.0",
+        typescript: "^4.8.4"
+      },
+      engines: {
+        node: ">=12"
+      },
+      browser: {
+        fs: false
+      }
+    };
+  }
+});
+
+// node_modules/dotenv/lib/main.js
+var require_main = __commonJS({
+  "node_modules/dotenv/lib/main.js"(exports, module) {
+    var fs = __require("fs");
+    var path = __require("path");
+    var os = __require("os");
+    var crypto = __require("crypto");
+    var packageJson = require_package();
+    var version = packageJson.version;
+    var TIPS = [
+      "\u{1F510} encrypt with Dotenvx: https://dotenvx.com",
+      "\u{1F510} prevent committing .env to code: https://dotenvx.com/precommit",
+      "\u{1F510} prevent building .env in docker: https://dotenvx.com/prebuild",
+      "\u{1F4E1} observe env with Radar: https://dotenvx.com/radar",
+      "\u{1F4E1} auto-backup env with Radar: https://dotenvx.com/radar",
+      "\u{1F4E1} version env with Radar: https://dotenvx.com/radar",
+      "\u{1F6E0}\uFE0F  run anywhere with `dotenvx run -- yourcommand`",
+      "\u2699\uFE0F  specify custom .env file path with { path: '/custom/path/.env' }",
+      "\u2699\uFE0F  enable debug logging with { debug: true }",
+      "\u2699\uFE0F  override existing env vars with { override: true }",
+      "\u2699\uFE0F  suppress all logs with { quiet: true }",
+      "\u2699\uFE0F  write to custom object with { processEnv: myObject }",
+      "\u2699\uFE0F  load multiple .env files with { path: ['.env.local', '.env'] }"
+    ];
+    function _getRandomTip() {
+      return TIPS[Math.floor(Math.random() * TIPS.length)];
+    }
+    function parseBoolean(value) {
+      if (typeof value === "string") {
+        return !["false", "0", "no", "off", ""].includes(value.toLowerCase());
+      }
+      return Boolean(value);
+    }
+    function supportsAnsi() {
+      return process.stdout.isTTY;
+    }
+    function dim(text) {
+      return supportsAnsi() ? `\x1B[2m${text}\x1B[0m` : text;
+    }
+    var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
+    function parse(src) {
+      const obj = {};
+      let lines = src.toString();
+      lines = lines.replace(/\r\n?/mg, "\n");
+      let match;
+      while ((match = LINE.exec(lines)) != null) {
+        const key = match[1];
+        let value = match[2] || "";
+        value = value.trim();
+        const maybeQuote = value[0];
+        value = value.replace(/^(['"`])([\s\S]*)\1$/mg, "$2");
+        if (maybeQuote === '"') {
+          value = value.replace(/\\n/g, "\n");
+          value = value.replace(/\\r/g, "\r");
+        }
+        obj[key] = value;
+      }
+      return obj;
+    }
+    function _parseVault(options) {
+      options = options || {};
+      const vaultPath = _vaultPath(options);
+      options.path = vaultPath;
+      const result = DotenvModule.configDotenv(options);
+      if (!result.parsed) {
+        const err = new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`);
+        err.code = "MISSING_DATA";
+        throw err;
+      }
+      const keys = _dotenvKey(options).split(",");
+      const length = keys.length;
+      let decrypted;
+      for (let i = 0; i < length; i++) {
+        try {
+          const key = keys[i].trim();
+          const attrs = _instructions(result, key);
+          decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
+          break;
+        } catch (error) {
+          if (i + 1 >= length) {
+            throw error;
+          }
+        }
+      }
+      return DotenvModule.parse(decrypted);
+    }
+    function _warn(message) {
+      console.error(`[dotenv@${version}][WARN] ${message}`);
+    }
+    function _debug(message) {
+      console.log(`[dotenv@${version}][DEBUG] ${message}`);
+    }
+    function _log(message) {
+      console.log(`[dotenv@${version}] ${message}`);
+    }
+    function _dotenvKey(options) {
+      if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) {
+        return options.DOTENV_KEY;
+      }
+      if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) {
+        return process.env.DOTENV_KEY;
+      }
+      return "";
+    }
+    function _instructions(result, dotenvKey) {
+      let uri;
+      try {
+        uri = new URL(dotenvKey);
+      } catch (error) {
+        if (error.code === "ERR_INVALID_URL") {
+          const err = new Error("INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development");
+          err.code = "INVALID_DOTENV_KEY";
+          throw err;
+        }
+        throw error;
+      }
+      const key = uri.password;
+      if (!key) {
+        const err = new Error("INVALID_DOTENV_KEY: Missing key part");
+        err.code = "INVALID_DOTENV_KEY";
+        throw err;
+      }
+      const environment = uri.searchParams.get("environment");
+      if (!environment) {
+        const err = new Error("INVALID_DOTENV_KEY: Missing environment part");
+        err.code = "INVALID_DOTENV_KEY";
+        throw err;
+      }
+      const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`;
+      const ciphertext = result.parsed[environmentKey];
+      if (!ciphertext) {
+        const err = new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`);
+        err.code = "NOT_FOUND_DOTENV_ENVIRONMENT";
+        throw err;
+      }
+      return { ciphertext, key };
+    }
+    function _vaultPath(options) {
+      let possibleVaultPath = null;
+      if (options && options.path && options.path.length > 0) {
+        if (Array.isArray(options.path)) {
+          for (const filepath of options.path) {
+            if (fs.existsSync(filepath)) {
+              possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
+            }
+          }
+        } else {
+          possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
+        }
+      } else {
+        possibleVaultPath = path.resolve(process.cwd(), ".env.vault");
+      }
+      if (fs.existsSync(possibleVaultPath)) {
+        return possibleVaultPath;
+      }
+      return null;
+    }
+    function _resolveHome(envPath) {
+      return envPath[0] === "~" ? path.join(os.homedir(), envPath.slice(1)) : envPath;
+    }
+    function _configVault(options) {
+      const debug = parseBoolean(process.env.DOTENV_CONFIG_DEBUG || options && options.debug);
+      const quiet = parseBoolean(process.env.DOTENV_CONFIG_QUIET || options && options.quiet);
+      if (debug || !quiet) {
+        _log("Loading env from encrypted .env.vault");
+      }
+      const parsed = DotenvModule._parseVault(options);
+      let processEnv = process.env;
+      if (options && options.processEnv != null) {
+        processEnv = options.processEnv;
+      }
+      DotenvModule.populate(processEnv, parsed, options);
+      return { parsed };
+    }
+    function configDotenv(options) {
+      const dotenvPath = path.resolve(process.cwd(), ".env");
+      let encoding = "utf8";
+      let processEnv = process.env;
+      if (options && options.processEnv != null) {
+        processEnv = options.processEnv;
+      }
+      let debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || options && options.debug);
+      let quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || options && options.quiet);
+      if (options && options.encoding) {
+        encoding = options.encoding;
+      } else {
+        if (debug) {
+          _debug("No encoding is specified. UTF-8 is used by default");
+        }
+      }
+      let optionPaths = [dotenvPath];
+      if (options && options.path) {
+        if (!Array.isArray(options.path)) {
+          optionPaths = [_resolveHome(options.path)];
+        } else {
+          optionPaths = [];
+          for (const filepath of options.path) {
+            optionPaths.push(_resolveHome(filepath));
+          }
+        }
+      }
+      let lastError;
+      const parsedAll = {};
+      for (const path2 of optionPaths) {
+        try {
+          const parsed = DotenvModule.parse(fs.readFileSync(path2, { encoding }));
+          DotenvModule.populate(parsedAll, parsed, options);
+        } catch (e) {
+          if (debug) {
+            _debug(`Failed to load ${path2} ${e.message}`);
+          }
+          lastError = e;
+        }
+      }
+      const populated = DotenvModule.populate(processEnv, parsedAll, options);
+      debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || debug);
+      quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || quiet);
+      if (debug || !quiet) {
+        const keysCount = Object.keys(populated).length;
+        const shortPaths = [];
+        for (const filePath of optionPaths) {
+          try {
+            const relative = path.relative(process.cwd(), filePath);
+            shortPaths.push(relative);
+          } catch (e) {
+            if (debug) {
+              _debug(`Failed to load ${filePath} ${e.message}`);
+            }
+            lastError = e;
+          }
+        }
+        _log(`injecting env (${keysCount}) from ${shortPaths.join(",")} ${dim(`-- tip: ${_getRandomTip()}`)}`);
+      }
+      if (lastError) {
+        return { parsed: parsedAll, error: lastError };
+      } else {
+        return { parsed: parsedAll };
+      }
+    }
+    function config(options) {
+      if (_dotenvKey(options).length === 0) {
+        return DotenvModule.configDotenv(options);
+      }
+      const vaultPath = _vaultPath(options);
+      if (!vaultPath) {
+        _warn(`You set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}. Did you forget to build it?`);
+        return DotenvModule.configDotenv(options);
+      }
+      return DotenvModule._configVault(options);
+    }
+    function decrypt(encrypted, keyStr) {
+      const key = Buffer.from(keyStr.slice(-64), "hex");
+      let ciphertext = Buffer.from(encrypted, "base64");
+      const nonce = ciphertext.subarray(0, 12);
+      const authTag = ciphertext.subarray(-16);
+      ciphertext = ciphertext.subarray(12, -16);
+      try {
+        const aesgcm = crypto.createDecipheriv("aes-256-gcm", key, nonce);
+        aesgcm.setAuthTag(authTag);
+        return `${aesgcm.update(ciphertext)}${aesgcm.final()}`;
+      } catch (error) {
+        const isRange = error instanceof RangeError;
+        const invalidKeyLength = error.message === "Invalid key length";
+        const decryptionFailed = error.message === "Unsupported state or unable to authenticate data";
+        if (isRange || invalidKeyLength) {
+          const err = new Error("INVALID_DOTENV_KEY: It must be 64 characters long (or more)");
+          err.code = "INVALID_DOTENV_KEY";
+          throw err;
+        } else if (decryptionFailed) {
+          const err = new Error("DECRYPTION_FAILED: Please check your DOTENV_KEY");
+          err.code = "DECRYPTION_FAILED";
+          throw err;
+        } else {
+          throw error;
+        }
+      }
+    }
+    function populate(processEnv, parsed, options = {}) {
+      const debug = Boolean(options && options.debug);
+      const override = Boolean(options && options.override);
+      const populated = {};
+      if (typeof parsed !== "object") {
+        const err = new Error("OBJECT_REQUIRED: Please check the processEnv argument being passed to populate");
+        err.code = "OBJECT_REQUIRED";
+        throw err;
+      }
+      for (const key of Object.keys(parsed)) {
+        if (Object.prototype.hasOwnProperty.call(processEnv, key)) {
+          if (override === true) {
+            processEnv[key] = parsed[key];
+            populated[key] = parsed[key];
+          }
+          if (debug) {
+            if (override === true) {
+              _debug(`"${key}" is already defined and WAS overwritten`);
+            } else {
+              _debug(`"${key}" is already defined and was NOT overwritten`);
+            }
+          }
+        } else {
+          processEnv[key] = parsed[key];
+          populated[key] = parsed[key];
+        }
+      }
+      return populated;
+    }
+    var DotenvModule = {
+      configDotenv,
+      _configVault,
+      _parseVault,
+      config,
+      decrypt,
+      parse,
+      populate
+    };
+    module.exports.configDotenv = DotenvModule.configDotenv;
+    module.exports._configVault = DotenvModule._configVault;
+    module.exports._parseVault = DotenvModule._parseVault;
+    module.exports.config = DotenvModule.config;
+    module.exports.decrypt = DotenvModule.decrypt;
+    module.exports.parse = DotenvModule.parse;
+    module.exports.populate = DotenvModule.populate;
+    module.exports = DotenvModule;
+  }
+});
+
+// package.json
+var require_package2 = __commonJS({
+  "package.json"(exports, module) {
+    module.exports = {
+      name: "mcp-jira-stdio",
+      version: "1.0.0",
+      description: "Model Context Protocol (MCP) server for Jira API integration",
+      author: "graslt",
+      license: "MIT",
+      type: "module",
+      main: "dist/index.js",
+      types: "dist/index.d.ts",
+      bin: {
+        "mcp-jira-stdio": "./dist/index.js"
+      },
+      scripts: {
+        dev: "tsx watch src/index.ts",
+        build: "tsup",
+        start: "node dist/index.js",
+        clean: "rm -rf dist",
+        typecheck: "tsc --noEmit",
+        lint: "eslint src --ext .ts",
+        "lint:fix": "eslint src --ext .ts --fix",
+        format: "prettier --write .",
+        "format:check": "prettier --check .",
+        check: "npm run typecheck && npm run lint && npm run format:check",
+        "check:all": "npm run check && npm run test:run && npm run build",
+        prepublishOnly: "npm run clean && npm run build",
+        inspector: "npx @modelcontextprotocol/inspector node dist/index.js",
+        "inspector:dev": "NODE_ENV=development npx @modelcontextprotocol/inspector npx tsx src/index.ts",
+        "setup:mcp": "node scripts/setup-mcp-config.js",
+        test: "vitest",
+        "test:run": "vitest run",
+        "test:coverage": "vitest run --coverage",
+        "test:watch": "vitest watch",
+        "test:ui": "vitest --ui",
+        "test:connection": "node scripts/test-connection.cjs"
+      },
+      keywords: [
+        "mcp",
+        "model-context-protocol",
+        "jira",
+        "atlassian",
+        "api",
+        "claude",
+        "ai"
+      ],
+      engines: {
+        node: ">=18.0.0"
+      },
+      dependencies: {
+        "@modelcontextprotocol/sdk": "^1.17.1",
+        zod: "^3.22.4",
+        axios: "^1.7.0"
+      },
+      devDependencies: {
+        "@types/node": "^22.5.0",
+        "@typescript-eslint/eslint-plugin": "^8.0.0",
+        "@typescript-eslint/parser": "^8.0.0",
+        "@vitest/coverage-v8": "^2.0.0",
+        "@vitest/ui": "^2.0.0",
+        dotenv: "^17.2.1",
+        eslint: "^9.9.0",
+        "eslint-config-prettier": "^9.1.0",
+        "eslint-plugin-prettier": "^5.2.0",
+        prettier: "^3.5.0",
+        tsup: "^8.0.0",
+        tsx: "^4.16.0",
+        typescript: "^5.5.0",
+        vitest: "^2.0.0"
+      },
+      files: [
+        "dist",
+        "README.md",
+        "LICENSE",
+        "scripts"
+      ],
+      repository: {
+        type: "git",
+        url: "git+https://github.com/freema/mcp-jira-stdio.git"
+      },
+      bugs: {
+        url: "https://github.com/freema/mcp-jira-stdio/issues"
+      },
+      homepage: "https://github.com/freema/mcp-jira-stdio#readme",
+      publishConfig: {
+        access: "public"
+      }
+    };
+  }
+});
+
+// src/config/constants.ts
+var JIRA_CONFIG = {
+  BASE_PATH: "/rest/api/3",
+  DEFAULT_TIMEOUT: 3e4,
+  MAX_RETRIES: 3,
+  RETRY_DELAY: 1e3};
+var ERROR_MESSAGES = {
+  AUTH_REQUIRED: "Jira authentication required. Set JIRA_BASE_URL, JIRA_EMAIL, and JIRA_API_TOKEN environment variables.",
+  INVALID_CREDENTIALS: "Invalid Jira credentials. Please check your email and API token.",
+  RATE_LIMIT_EXCEEDED: "Jira API rate limit exceeded. Please wait and try again.",
+  NETWORK_ERROR: "Network error occurred while connecting to Jira.",
+  VALIDATION_ERROR: "Input validation failed."
+};
+var TOOL_NAMES = {
+  GET_VISIBLE_PROJECTS: "jira_get_visible_projects",
+  GET_ISSUE: "jira_get_issue",
+  SEARCH_ISSUES: "jira_search_issues",
+  GET_MY_ISSUES: "jira_get_my_issues",
+  GET_ISSUE_TYPES: "jira_get_issue_types",
+  GET_USERS: "jira_get_users",
+  GET_PRIORITIES: "jira_get_priorities",
+  GET_STATUSES: "jira_get_statuses",
+  CREATE_ISSUE: "jira_create_issue",
+  UPDATE_ISSUE: "jira_update_issue",
+  ADD_COMMENT: "jira_add_comment",
+  GET_PROJECT_INFO: "jira_get_project_info",
+  CREATE_SUBTASK: "jira_create_subtask"
+};
+
+// src/utils/logger.ts
+var levels = {
+  debug: 10,
+  info: 20,
+  warn: 30,
+  error: 40,
+  silent: 99
+};
+function getLevel() {
+  const env = (process.env.LOG_LEVEL || (process.env.NODE_ENV === "development" ? "debug" : "info")).toLowerCase();
+  if (env === "debug" || env === "info" || env === "warn" || env === "error" || env === "silent")
+    return env;
+  return "info";
+}
+function createLogger(scope) {
+  const level = getLevel();
+  const min = levels[level];
+  const fmt = (msg) => typeof msg === "string" ? msg : JSON.stringify(msg);
+  const prefix = (lvl) => `[${lvl.toUpperCase()}] ${scope}:`;
+  return {
+    debug: (...args) => {
+      if (min <= levels.debug) console.error(prefix("debug"), ...args.map(fmt));
+    },
+    info: (...args) => {
+      if (min <= levels.info) console.error(prefix("info"), ...args.map(fmt));
+    },
+    warn: (...args) => {
+      if (min <= levels.warn) console.error(prefix("warn"), ...args.map(fmt));
+    },
+    error: (...args) => {
+      if (min <= levels.error) console.error(prefix("error"), ...args.map(fmt));
+    }
+  };
+}
+
+// src/utils/jira-auth.ts
+var jiraClient = null;
+var log = createLogger("jira-auth");
+function validateAuth() {
+  const baseUrl = process.env.JIRA_BASE_URL;
+  const email = process.env.JIRA_EMAIL;
+  const apiToken = process.env.JIRA_API_TOKEN;
+  if (!baseUrl || !email || !apiToken) {
+    throw new Error(ERROR_MESSAGES.AUTH_REQUIRED);
+  }
+  const normalizedBaseUrl = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+  return {
+    baseUrl: normalizedBaseUrl,
+    email,
+    apiToken
+  };
+}
+function getAuthenticatedClient() {
+  if (jiraClient) {
+    return jiraClient;
+  }
+  const auth = validateAuth();
+  jiraClient = axios.create({
+    baseURL: `${auth.baseUrl}${JIRA_CONFIG.BASE_PATH}`,
+    timeout: JIRA_CONFIG.DEFAULT_TIMEOUT,
+    headers: {
+      Accept: "application/json",
+      "Content-Type": "application/json"
+    },
+    auth: {
+      username: auth.email,
+      password: auth.apiToken
+    }
+  });
+  jiraClient.interceptors.request.use(
+    (config) => {
+      log.debug(`Request: ${config.method?.toUpperCase()} ${config.baseURL}${config.url}`);
+      return config;
+    },
+    (error) => {
+      log.error("Request error:", error);
+      return Promise.reject(error);
+    }
+  );
+  jiraClient.interceptors.response.use(
+    (response) => {
+      log.debug(`Response: ${response.status} ${response.config.url}`);
+      return response;
+    },
+    (error) => {
+      log.error(`Jira API error: ${error.response?.status} ${error.config?.url}`);
+      if (error.response?.status === 401) {
+        throw new Error(ERROR_MESSAGES.INVALID_CREDENTIALS);
+      } else if (error.response?.status === 404) {
+        throw new Error("Resource not found or insufficient permissions");
+      } else if (error.response?.status === 429) {
+        throw new Error(ERROR_MESSAGES.RATE_LIMIT_EXCEEDED);
+      } else if (!error.response) {
+        throw new Error(ERROR_MESSAGES.NETWORK_ERROR);
+      }
+      return Promise.reject(error);
+    }
+  );
+  return jiraClient;
+}
+async function makeJiraRequest(config, retryConfig = {
+  maxRetries: JIRA_CONFIG.MAX_RETRIES,
+  retryDelay: JIRA_CONFIG.RETRY_DELAY
+}) {
+  const client = getAuthenticatedClient();
+  let lastError;
+  for (let attempt = 0; attempt <= retryConfig.maxRetries; attempt++) {
+    try {
+      const response = await client.request(config);
+      return response.data;
+    } catch (error) {
+      lastError = error;
+      if (error.response?.status === 401 || error.response?.status === 403 || error.response?.status === 404 || error.response?.status >= 400 && error.response?.status < 500 && error.response?.status !== 429) {
+        break;
+      }
+      if (retryConfig.retryCondition && !retryConfig.retryCondition(error)) {
+        break;
+      }
+      if (attempt === retryConfig.maxRetries) {
+        break;
+      }
+      const retryAfterHeader = error.response?.headers?.["retry-after"];
+      let delayMs = 0;
+      if (retryAfterHeader) {
+        const seconds = Number(retryAfterHeader);
+        delayMs = !Number.isNaN(seconds) ? seconds * 1e3 : retryConfig.retryDelay;
+      } else {
+        const base = retryConfig.retryDelay * Math.pow(2, attempt);
+        const jitter = Math.floor(Math.random() * (retryConfig.retryDelay / 2));
+        delayMs = base + jitter;
+      }
+      log.warn(
+        `Retrying request in ${delayMs}ms (attempt ${attempt + 1}/${retryConfig.maxRetries})`
+      );
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+    }
+  }
+  throw lastError;
+}
+async function testConnection() {
+  try {
+    await makeJiraRequest({
+      method: "GET",
+      url: "/myself"
+    });
+    return true;
+  } catch (error) {
+    log.error("Connection test failed:", error);
+    return false;
+  }
+}
+function validateInput(schema, input) {
+  try {
+    return schema.parse(input);
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      const errorMessages = error.errors.map((err) => `${err.path.join(".")}: ${err.message}`);
+      throw new Error(`${ERROR_MESSAGES.VALIDATION_ERROR}
+${errorMessages.join("\n")}`);
+    }
+    throw error;
+  }
+}
+function isValidIssueKey(key) {
+  return /^[A-Z][A-Z0-9]*-\d+$/.test(key);
+}
+function isValidProjectKey(key) {
+  return /^[A-Z][A-Z0-9]{0,9}$/.test(key);
+}
+function sanitizeJQL(jql) {
+  return jql.replace(/[<>"'`]/g, "").replace(/\s+/g, " ").trim();
+}
+function validatePagination(startAt, maxResults) {
+  if (startAt < 0) {
+    throw new Error("startAt must be non-negative");
+  }
+  if (maxResults < 1 || maxResults > 100) {
+    throw new Error("maxResults must be between 1 and 100");
+  }
+}
+
+// src/types/tools.ts
+var GetVisibleProjectsInputSchema = z.object({
+  expand: z.array(z.string()).optional().describe("Additional project details to include"),
+  recent: z.number().optional().describe("Limit to recently accessed projects")
+});
+var GetIssueInputSchema = z.object({
+  issueKey: z.string().min(1).describe(
+    "Issue key or full Jira URL (e.g., PROJECT-123 or https://your.atlassian.net/browse/PROJECT-123)"
+  ),
+  expand: z.array(z.string()).optional().describe("Additional issue details to include"),
+  fields: z.array(z.string()).optional().describe("Specific fields to retrieve")
+});
+var SearchIssuesInputSchema = z.object({
+  jql: z.string().min(1).describe("JQL query string"),
+  startAt: z.number().min(0).default(0).describe("Index of first result to return"),
+  maxResults: z.number().min(1).max(100).default(50).describe("Maximum number of results to return"),
+  fields: z.array(z.string()).optional().describe("Specific fields to retrieve"),
+  expand: z.array(z.string()).optional().describe("Additional details to include")
+});
+var CreateIssueInputSchema = z.object({
+  projectKey: z.string().describe("Project key where the issue will be created").refine((v) => isValidProjectKey(v), "Invalid project key format"),
+  summary: z.string().min(1).describe("Issue summary/title"),
+  description: z.string().optional().describe("Issue description"),
+  issueType: z.string().describe("Issue type (e.g., Bug, Story, Task)"),
+  priority: z.string().optional().describe("Issue priority"),
+  assignee: z.string().optional().describe("Assignee account ID"),
+  labels: z.array(z.string()).optional().describe("Issue labels"),
+  components: z.array(z.string()).optional().describe("Component names"),
+  returnIssue: z.boolean().optional().describe("When false, skip fetching full issue after creation")
+});
+var UpdateIssueInputSchema = z.object({
+  issueKey: z.string().describe("Issue key to update").refine((v) => isValidIssueKey(v), "Invalid issue key format"),
+  summary: z.string().optional().describe("New summary"),
+  description: z.string().optional().describe("New description"),
+  priority: z.string().optional().describe("New priority"),
+  assignee: z.string().optional().describe("New assignee account ID"),
+  labels: z.array(z.string()).optional().describe("New labels (replaces existing)"),
+  components: z.array(z.string()).optional().describe("New components (replaces existing)"),
+  returnIssue: z.boolean().optional().describe("When false, skip fetching full issue after update")
+});
+var GetMyIssuesInputSchema = z.object({
+  startAt: z.number().min(0).default(0).describe("Index of first result to return"),
+  maxResults: z.number().min(1).max(100).default(50).describe("Maximum number of results to return"),
+  fields: z.array(z.string()).optional().describe("Specific fields to retrieve"),
+  expand: z.array(z.string()).optional().describe("Additional details to include")
+});
+var GetIssueTypesInputSchema = z.object({
+  projectKey: z.string().optional().describe("Project key to get issue types for specific project").refine((v) => v ? isValidProjectKey(v) : true, "Invalid project key format")
+});
+var GetUsersInputSchema = z.object({
+  query: z.string().optional().describe("Search query for user name or email"),
+  username: z.string().optional().describe("Specific username to search for"),
+  accountId: z.string().optional().describe("Specific account ID to search for"),
+  startAt: z.number().min(0).default(0).describe("Index of first result to return"),
+  maxResults: z.number().min(1).max(50).default(50).describe("Maximum number of results to return")
+});
+var GetPrioritiesInputSchema = z.object({});
+var GetStatusesInputSchema = z.object({
+  projectKey: z.string().optional().describe("Project key to get statuses for specific project").refine((v) => v ? isValidProjectKey(v) : true, "Invalid project key format"),
+  issueTypeId: z.string().optional().describe("Issue type ID to get statuses for specific issue type")
+});
+var AddCommentInputSchema = z.object({
+  issueKey: z.string().describe("Issue key to add comment to").refine((v) => isValidIssueKey(v), "Invalid issue key format"),
+  body: z.string().min(1).describe("Comment body text"),
+  visibility: z.object({
+    type: z.enum(["group", "role"]).describe("Visibility type"),
+    value: z.string().describe("Group name or role name")
+  }).optional().describe("Comment visibility restrictions")
+});
+var GetProjectInfoInputSchema = z.object({
+  projectKey: z.string().describe("Project key to get detailed information for").refine((v) => isValidProjectKey(v), "Invalid project key format"),
+  expand: z.array(z.string()).optional().describe("Additional project details to include")
+});
+var CreateSubtaskInputSchema = z.object({
+  parentIssueKey: z.string().describe("Parent issue key"),
+  summary: z.string().min(1).describe("Subtask summary/title"),
+  description: z.string().optional().describe("Subtask description"),
+  priority: z.string().optional().describe("Subtask priority"),
+  assignee: z.string().optional().describe("Assignee account ID"),
+  labels: z.array(z.string()).optional().describe("Subtask labels"),
+  components: z.array(z.string()).optional().describe("Component names")
+});
+
+// src/utils/api-helpers.ts
+async function getVisibleProjects(options = {}) {
+  const params = {};
+  if (options.expand) {
+    params.expand = options.expand.join(",");
+  }
+  if (options.recent) {
+    params.recent = options.recent;
+  }
+  const config = {
+    method: "GET",
+    url: "/project/search",
+    params
+  };
+  const response = await makeJiraRequest(config);
+  return response.values;
+}
+async function getIssue(issueKey, options = {}) {
+  const params = {};
+  if (options.expand) {
+    params.expand = options.expand.join(",");
+  }
+  if (options.fields) {
+    params.fields = options.fields.join(",");
+  }
+  const config = {
+    method: "GET",
+    url: `/issue/${issueKey}`,
+    params
+  };
+  return await makeJiraRequest(config);
+}
+async function searchIssues(options) {
+  const { jql, startAt = 0, maxResults = 50 } = options;
+  validatePagination(startAt, maxResults);
+  const sanitizedJql = sanitizeJQL(jql);
+  const data = {
+    jql: sanitizedJql,
+    startAt,
+    maxResults
+  };
+  if (options.fields) {
+    data.fields = options.fields;
+  }
+  if (options.expand) {
+    data.expand = options.expand;
+  }
+  const config = {
+    method: "POST",
+    url: "/search",
+    data
+  };
+  return await makeJiraRequest(config);
+}
+async function createIssue(issueData, options = { returnIssue: true }) {
+  const fields = {
+    project: { key: issueData.projectKey },
+    summary: issueData.summary,
+    issuetype: { name: issueData.issueType }
+  };
+  if (issueData.description) {
+    fields.description = issueData.description;
+  }
+  if (issueData.priority) {
+    fields.priority = { name: issueData.priority };
+  }
+  if (issueData.assignee) {
+    fields.assignee = { accountId: issueData.assignee };
+  }
+  if (issueData.labels && issueData.labels.length > 0) {
+    fields.labels = issueData.labels;
+  }
+  if (issueData.components && issueData.components.length > 0) {
+    fields.components = issueData.components.map((name) => ({ name }));
+  }
+  const config = {
+    method: "POST",
+    url: "/issue",
+    data: { fields }
+  };
+  const response = await makeJiraRequest(config);
+  if (options.returnIssue === false) {
+    return response.key;
+  }
+  return await getIssue(response.key);
+}
+async function updateIssue(issueKey, updates) {
+  const fields = {};
+  if (updates.summary !== void 0) {
+    fields.summary = updates.summary;
+  }
+  if (updates.description !== void 0) {
+    fields.description = updates.description;
+  }
+  if (updates.priority !== void 0) {
+    fields.priority = { name: updates.priority };
+  }
+  if (updates.assignee !== void 0) {
+    fields.assignee = updates.assignee ? { accountId: updates.assignee } : null;
+  }
+  if (updates.labels !== void 0) {
+    fields.labels = updates.labels;
+  }
+  if (updates.components !== void 0) {
+    fields.components = updates.components.map((name) => ({ name }));
+  }
+  const config = {
+    method: "PUT",
+    url: `/issue/${issueKey}`,
+    data: { fields }
+  };
+  await makeJiraRequest(config);
+}
+async function getMyIssues(options = {}) {
+  const jql = `assignee = currentUser() ORDER BY updated DESC`;
+  const searchParams = {
+    jql,
+    startAt: options.startAt || 0,
+    maxResults: options.maxResults || 50
+  };
+  if (options.fields !== void 0) searchParams.fields = options.fields;
+  if (options.expand !== void 0) searchParams.expand = options.expand;
+  return await searchIssues(searchParams);
+}
+async function getIssueTypes(projectKey) {
+  let url = "/issuetype";
+  if (projectKey) {
+    url = `/project/${projectKey}/issuetype`;
+  }
+  const config = {
+    method: "GET",
+    url
+  };
+  return await makeJiraRequest(config);
+}
+async function getUsers(options = {}) {
+  const params = {};
+  if (options.query) {
+    params.query = options.query;
+  }
+  if (options.username) {
+    params.username = options.username;
+  }
+  if (options.accountId) {
+    params.accountId = options.accountId;
+  }
+  if (options.startAt !== void 0) {
+    params.startAt = options.startAt;
+  }
+  if (options.maxResults !== void 0) {
+    params.maxResults = options.maxResults;
+  }
+  const config = {
+    method: "GET",
+    url: "/user/search",
+    params
+  };
+  return await makeJiraRequest(config);
+}
+async function getPriorities() {
+  const config = {
+    method: "GET",
+    url: "/priority"
+  };
+  return await makeJiraRequest(config);
+}
+async function getStatuses(options = {}) {
+  let url = "/status";
+  if (options.projectKey && options.issueTypeId) {
+    url = `/project/${options.projectKey}/statuses`;
+  } else if (options.projectKey) {
+    url = `/project/${options.projectKey}/statuses`;
+  }
+  const config = {
+    method: "GET",
+    url
+  };
+  if (options.projectKey) {
+    const response = await makeJiraRequest(config);
+    if (options.issueTypeId) {
+      const match = response.find(
+        (issueType) => issueType.id === options.issueTypeId || issueType.name === options.issueTypeId
+      );
+      if (match) return match.statuses;
+    }
+    return response.flatMap((issueType) => issueType.statuses);
+  }
+  return await makeJiraRequest(config);
+}
+async function addComment(issueKey, body, visibility) {
+  const data = { body };
+  if (visibility) {
+    data.visibility = visibility;
+  }
+  const config = {
+    method: "POST",
+    url: `/issue/${issueKey}/comment`,
+    data
+  };
+  return await makeJiraRequest(config);
+}
+async function getProjectDetails(projectKey, expand) {
+  const params = {};
+  if (expand) {
+    params.expand = expand.join(",");
+  }
+  const config = {
+    method: "GET",
+    url: `/project/${projectKey}`,
+    params
+  };
+  return await makeJiraRequest(config);
+}
+async function createSubtask(parentIssueKey, subtaskData) {
+  const parentIssue = await getIssue(parentIssueKey);
+  const projectKey = parentIssue.fields.project.key;
+  const issueTypes = await getIssueTypes(projectKey);
+  const subtaskType = issueTypes.find((type) => type.subtask);
+  if (!subtaskType) {
+    throw new Error(`No subtask issue type found for project ${projectKey}`);
+  }
+  const fields = {
+    project: { key: projectKey },
+    parent: { key: parentIssueKey },
+    summary: subtaskData.summary,
+    issuetype: { id: subtaskType.id }
+  };
+  if (subtaskData.description) {
+    fields.description = subtaskData.description;
+  }
+  if (subtaskData.priority) {
+    fields.priority = { name: subtaskData.priority };
+  }
+  if (subtaskData.assignee) {
+    fields.assignee = { accountId: subtaskData.assignee };
+  }
+  if (subtaskData.labels && subtaskData.labels.length > 0) {
+    fields.labels = subtaskData.labels;
+  }
+  if (subtaskData.components && subtaskData.components.length > 0) {
+    fields.components = subtaskData.components.map((name) => ({ name }));
+  }
+  const config = {
+    method: "POST",
+    url: "/issue",
+    data: { fields }
+  };
+  const response = await makeJiraRequest(config);
+  return await getIssue(response.key);
+}
+
+// src/utils/redaction.ts
+function isRedactionEnabled() {
+  const val = process.env.MCP_REDACT_SENSITIVE || process.env.REDACT_SENSITIVE;
+  return val === "1" || val?.toLowerCase() === "true";
+}
+function maybeRedactAccountId(accountId) {
+  if (!accountId) return "N/A";
+  if (!isRedactionEnabled()) return accountId;
+  const head = accountId.slice(0, 4);
+  return `${head}\u2026`;
+}
+function maybeRedactEmail(email) {
+  if (!email) return "N/A";
+  if (!isRedactionEnabled()) return email;
+  return "hidden";
+}
+
+// src/utils/formatters.ts
+function formatProjectsResponse(projects) {
+  const projectsList = projects.map(
+    (project) => `\u2022 **${project.key}** - ${project.name}
+  ${project.description || "No description"}
+  Type: ${project.projectTypeKey} | Private: ${project.isPrivate ? "Yes" : "No"}`
+  ).join("\n\n");
+  return {
+    content: [
+      {
+        type: "text",
+        text: `Found ${projects.length} visible project(s):
+
+${projectsList}`
+      }
+    ]
+  };
+}
+function adfToPlainText(adf) {
+  try {
+    const walk = (node) => {
+      if (!node) return "";
+      switch (node.type) {
+        case "text":
+          return node.text || "";
+        case "paragraph":
+        case "heading":
+        case "blockquote":
+          return (node.content || []).map(walk).join("");
+        case "codeBlock":
+          return "\n" + (node.content || []).map(walk).join("") + "\n";
+        case "bulletList":
+        case "orderedList":
+          return (node.content || []).map(walk).join("\n");
+        case "listItem":
+          return "\u2022 " + (node.content || []).map(walk).join("");
+        case "hardBreak":
+          return "\n";
+        default:
+          if (Array.isArray(node.content)) return node.content.map(walk).join("");
+          return "";
+      }
+    };
+    if (adf && Array.isArray(adf.content)) {
+      return adf.content.map(walk).join("\n").trim();
+    }
+  } catch {
+  }
+  return "";
+}
+function formatIssueResponse(issue) {
+  const { key, fields } = issue;
+  const summary = fields?.summary || "No summary";
+  const assigneeText = fields?.assignee ? `${fields.assignee.displayName} (${maybeRedactAccountId(fields.assignee.accountId)})` : "Unassigned";
+  const reporterText = fields?.reporter ? `${fields.reporter.displayName} (${maybeRedactAccountId(fields.reporter.accountId)})` : "Unknown";
+  const labelsArray = Array.isArray(fields?.labels) ? fields.labels : [];
+  const labelsText = labelsArray.length > 0 ? labelsArray.join(", ") : "None";
+  const componentsArray = Array.isArray(fields?.components) ? fields.components : [];
+  const componentsText = componentsArray.length > 0 ? componentsArray.map((c) => c.name).join(", ") : "None";
+  let description = fields?.description;
+  if (description && typeof description === "object") {
+    const parsed = adfToPlainText(description);
+    description = parsed || "[rich text description omitted]";
+  }
+  if (!description || typeof description !== "string") {
+    description = "No description provided";
+  }
+  const createdText = fields?.created ? new Date(fields.created).toISOString() : "N/A";
+  const updatedText = fields?.updated ? new Date(fields.updated).toISOString() : "N/A";
+  return {
+    content: [
+      {
+        type: "text",
+        text: `**${key}: ${summary}**
+
+**Status:** ${fields?.status?.name || "Unknown"}
+**Priority:** ${fields?.priority?.name || "None"}
+**Assignee:** ${assigneeText}
+**Reporter:** ${reporterText}
+**Project:** ${fields?.project?.name || "Unknown"} (${fields?.project?.key || "N/A"})
+**Issue Type:** ${fields?.issuetype?.name || "Unknown"}
+**Labels:** ${labelsText}
+**Components:** ${componentsText}
+**Created:** ${createdText}
+**Updated:** ${updatedText}
+
+**Description:**
+${description}`
+      }
+    ]
+  };
+}
+function formatSearchResultsResponse(result) {
+  if (result.issues.length === 0) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: "No issues found matching your search criteria."
+        }
+      ]
+    };
+  }
+  const issuesList = result.issues.map((issue) => {
+    const assignee = issue.fields.assignee?.displayName || "Unassigned";
+    return `\u2022 **${issue.key}** - ${issue.fields.summary}
+  Status: ${issue.fields.status.name} | Assignee: ${assignee} | Priority: ${issue.fields.priority?.name || "None"}`;
+  }).join("\n\n");
+  const paginationInfo = result.total > result.maxResults ? `
+
+*Showing ${result.startAt + 1}-${Math.min(result.startAt + result.maxResults, result.total)} of ${result.total} results*` : "";
+  return {
+    content: [
+      {
+        type: "text",
+        text: `Found ${result.total} issue(s):
+
+${issuesList}${paginationInfo}`
+      }
+    ]
+  };
+}
+function formatErrorResponse(error) {
+  let errorMessage = "An unexpected error occurred.";
+  if (typeof error === "string") {
+    errorMessage = error;
+  } else if (error instanceof Error) {
+    errorMessage = error.message;
+  } else if (error?.response?.data) {
+    const jiraError = error.response.data;
+    if (jiraError.errorMessages && jiraError.errorMessages.length > 0) {
+      errorMessage = jiraError.errorMessages.join(", ");
+    } else if (jiraError.errors) {
+      errorMessage = Object.entries(jiraError.errors).map(([field, message]) => `${field}: ${message}`).join(", ");
+    }
+  }
+  return {
+    content: [
+      {
+        type: "text",
+        text: `\u274C Error: ${errorMessage}`
+      }
+    ]
+  };
+}
+function formatSuccessResponse(message) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: `\u2705 ${message}`
+      }
+    ]
+  };
+}
+function formatUsersResponse(users) {
+  if (users.length === 0) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: "No users found matching your search criteria."
+        }
+      ]
+    };
+  }
+  const usersList = users.map(
+    (user) => `\u2022 **${user.displayName}** (${maybeRedactAccountId(user.accountId)})
+  Email: ${maybeRedactEmail(user.emailAddress)} | Active: ${user.active ? "Yes" : "No"} | Type: ${user.accountType}`
+  ).join("\n\n");
+  return {
+    content: [
+      {
+        type: "text",
+        text: `Found ${users.length} user(s):
+
+${usersList}`
+      }
+    ]
+  };
+}
+function formatIssueTypesResponse(issueTypes) {
+  if (issueTypes.length === 0) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: "No issue types found."
+        }
+      ]
+    };
+  }
+  const typesList = issueTypes.map(
+    (type) => `\u2022 **${type.name}** (ID: ${type.id})
+  ${type.description}
+  Subtask: ${type.subtask ? "Yes" : "No"}`
+  ).join("\n\n");
+  return {
+    content: [
+      {
+        type: "text",
+        text: `Found ${issueTypes.length} issue type(s):
+
+${typesList}`
+      }
+    ]
+  };
+}
+function formatPrioritiesResponse(priorities) {
+  if (priorities.length === 0) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: "No priorities found."
+        }
+      ]
+    };
+  }
+  const prioritiesList = priorities.map((priority) => `\u2022 **${priority.name}** (ID: ${priority.id})
+  ${priority.description}`).join("\n\n");
+  return {
+    content: [
+      {
+        type: "text",
+        text: `Found ${priorities.length} priority level(s):
+
+${prioritiesList}`
+      }
+    ]
+  };
+}
+function formatStatusesResponse(statuses) {
+  if (statuses.length === 0) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: "No statuses found."
+        }
+      ]
+    };
+  }
+  const statusesList = statuses.map(
+    (status) => `\u2022 **${status.name}** (ID: ${status.id})
+  ${status.description}
+  Category: ${status.statusCategory.name} (${status.statusCategory.key})`
+  ).join("\n\n");
+  return {
+    content: [
+      {
+        type: "text",
+        text: `Found ${statuses.length} status(es):
+
+${statusesList}`
+      }
+    ]
+  };
+}
+function formatCommentResponse(comment) {
+  const visibilityText = comment.visibility ? `
+**Visibility:** ${comment.visibility.type} - ${comment.visibility.value}` : "";
+  return {
+    content: [
+      {
+        type: "text",
+        text: `**Comment added successfully**
+
+**Author:** ${comment.author.displayName}
+**Created:** ${new Date(comment.created).toISOString()}${visibilityText}
+
+**Content:**
+${comment.body}`
+      }
+    ]
+  };
+}
+function formatProjectDetailsResponse(project) {
+  const leadText = project.lead ? `${project.lead.displayName} (${project.lead.accountId})` : "No lead assigned";
+  const componentsText = project.components.length > 0 ? project.components.map((c) => c.name).join(", ") : "None";
+  const versionsText = project.versions.length > 0 ? project.versions.map((v) => v.name).join(", ") : "None";
+  const issueTypesText = project.issueTypes.length > 0 ? project.issueTypes.map((t) => `${t.name}${t.subtask ? " (Subtask)" : ""}`).join(", ") : "None";
+  const rolesText = Object.keys(project.roles).length > 0 ? Object.keys(project.roles).join(", ") : "None";
+  const insightText = project.insight ? `
+
+**Project Insights:**
+Total Issues: ${project.insight.totalIssueCount}
+Last Updated: ${new Date(project.insight.lastIssueUpdateTime).toISOString()}` : "";
+  return {
+    content: [
+      {
+        type: "text",
+        text: `**${project.key}: ${project.name}**
+
+**Description:** ${project.description || "No description"}
+**Type:** ${project.projectTypeKey}
+**Private:** ${project.isPrivate ? "Yes" : "No"}
+**Lead:** ${leadText}
+
+**Components:** ${componentsText}
+**Versions:** ${versionsText}
+**Issue Types:** ${issueTypesText}
+**Roles:** ${rolesText}${insightText}`
+      }
+    ]
+  };
+}
+
+// src/utils/error-handler.ts
+var log2 = createLogger("error-handler");
+var JiraApiError = class extends Error {
+  constructor(message, statusCode, jiraErrors, originalError) {
+    super(message);
+    this.statusCode = statusCode;
+    this.jiraErrors = jiraErrors;
+    this.originalError = originalError;
+    this.name = "JiraApiError";
+  }
+};
+function handleError(error) {
+  log2.error("Tool error:", error);
+  if (typeof error === "string") {
+    return formatErrorResponse(error);
+  }
+  if (error instanceof JiraApiError) {
+    return formatErrorResponse(error.message);
+  }
+  if (error?.response?.status === 401) {
+    return formatErrorResponse(ERROR_MESSAGES.INVALID_CREDENTIALS);
+  }
+  if (error?.response?.status === 404) {
+    return formatErrorResponse("Resource not found or insufficient permissions");
+  }
+  if (error?.response?.status === 429) {
+    return formatErrorResponse(ERROR_MESSAGES.RATE_LIMIT_EXCEEDED);
+  }
+  if (!error?.response && error?.code === "ECONNREFUSED") {
+    return formatErrorResponse(ERROR_MESSAGES.NETWORK_ERROR);
+  }
+  if (error?.message?.includes("validation")) {
+    return formatErrorResponse(error.message);
+  }
+  if (error?.response?.data) {
+    const jiraError = error.response.data;
+    if (jiraError.errorMessages && jiraError.errorMessages.length > 0) {
+      return formatErrorResponse(jiraError.errorMessages.join(", "));
+    }
+    if (jiraError.errors) {
+      const errorDetails = Object.entries(jiraError.errors).map(([field, message2]) => `${field}: ${message2}`).join(", ");
+      return formatErrorResponse(errorDetails);
+    }
+  }
+  const message = error?.message || "An unexpected error occurred";
+  return formatErrorResponse(message);
+}
+
+// src/tools/get-visible-projects.ts
+var log3 = createLogger("tool:get-visible-projects");
+var getVisibleProjectsTool = {
+  name: TOOL_NAMES.GET_VISIBLE_PROJECTS,
+  description: "Retrieves all projects accessible to the authenticated user. Returns project keys, names, descriptions, and basic metadata.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      expand: {
+        type: "array",
+        items: { type: "string" },
+        description: 'Additional project details to include (e.g., ["description", "lead", "issueTypes"])',
+        default: []
+      },
+      recent: {
+        type: "number",
+        description: "Limit results to recently accessed projects (max number)",
+        minimum: 1,
+        maximum: 100
+      }
+    },
+    required: []
+  }
+};
+async function handleGetVisibleProjects(input) {
+  try {
+    const validated = validateInput(GetVisibleProjectsInputSchema, input);
+    log3.info("Getting visible projects...");
+    const getParams = {};
+    if (validated.expand !== void 0) getParams.expand = validated.expand;
+    if (validated.recent !== void 0) getParams.recent = validated.recent;
+    const projects = await getVisibleProjects(getParams);
+    log3.info(`Found ${projects.length} project(s)`);
+    return formatProjectsResponse(projects);
+  } catch (error) {
+    log3.error("Error in handleGetVisibleProjects:", error);
+    return handleError(error);
+  }
+}
+
+// src/tools/get-issue.ts
+var log4 = createLogger("tool:get-issue");
+var getIssueTool = {
+  name: TOOL_NAMES.GET_ISSUE,
+  description: 'Retrieve details for a specific Jira issue by key or URL. Use this when the user mentions an issue like "PAYWALL-943" or pastes a Jira link (e.g., https://your.atlassian.net/browse/PAYWALL-943). Returns status, assignee, priority, project, type, labels, components, timestamps, and description.',
+  inputSchema: {
+    type: "object",
+    properties: {
+      issueKey: {
+        type: "string",
+        description: "Issue key or full Jira URL (e.g., PROJECT-123 or https://your.atlassian.net/browse/PROJECT-123)"
+      },
+      expand: {
+        type: "array",
+        items: { type: "string" },
+        description: 'Additional issue details to include (e.g., ["comments", "attachments", "changelog"])',
+        default: []
+      },
+      fields: {
+        type: "array",
+        items: { type: "string" },
+        description: 'Specific fields to retrieve (e.g., ["summary", "status", "assignee"])'
+      }
+    },
+    required: ["issueKey"]
+  }
+};
+async function handleGetIssue(input) {
+  try {
+    const validated = validateInput(GetIssueInputSchema, input);
+    const key = (validated.issueKey || "").trim();
+    log4.info(`Getting issue ${key}...`);
+    const getParams = {};
+    if (validated.expand !== void 0) getParams.expand = validated.expand;
+    if (validated.fields !== void 0) getParams.fields = validated.fields;
+    const issue = await getIssue(key, getParams);
+    log4.info(`Retrieved issue ${issue.key}`);
+    return formatIssueResponse(issue);
+  } catch (error) {
+    log4.error("Error in handleGetIssue:", error);
+    return handleError(error);
+  }
+}
+
+// src/tools/search-issues.ts
+var log5 = createLogger("tool:search-issues");
+var searchIssuesTool = {
+  name: TOOL_NAMES.SEARCH_ISSUES,
+  description: 'Search for Jira issues using JQL. Supports complex queries with pagination and field selection. Examples: "project = PROJECT AND status = Open", "assignee = currentUser()".',
+  inputSchema: {
+    type: "object",
+    properties: {
+      jql: {
+        type: "string",
+        description: 'JQL query string (e.g., "project = PROJECT AND status = Open")'
+      },
+      startAt: {
+        type: "number",
+        description: "Index of first result to return (for pagination)",
+        minimum: 0,
+        default: 0
+      },
+      maxResults: {
+        type: "number",
+        description: "Maximum number of results to return",
+        minimum: 1,
+        maximum: 100,
+        default: 50
+      },
+      fields: {
+        type: "array",
+        items: { type: "string" },
+        description: "Specific fields to retrieve for each issue"
+      },
+      expand: {
+        type: "array",
+        items: { type: "string" },
+        description: "Additional details to include for each issue",
+        default: []
+      }
+    },
+    required: ["jql"]
+  }
+};
+async function handleSearchIssues(input) {
+  try {
+    const validated = validateInput(SearchIssuesInputSchema, input);
+    log5.info(`Searching issues with JQL: "${validated.jql}"...`);
+    const searchParams = {
+      jql: validated.jql
+    };
+    if (validated.startAt !== void 0) searchParams.startAt = validated.startAt;
+    if (validated.maxResults !== void 0) searchParams.maxResults = validated.maxResults;
+    if (validated.fields !== void 0) searchParams.fields = validated.fields;
+    if (validated.expand !== void 0) searchParams.expand = validated.expand;
+    const result = await searchIssues(searchParams);
+    log5.info(`Found ${result.total} issue(s), showing ${result.issues.length}`);
+    return formatSearchResultsResponse(result);
+  } catch (error) {
+    log5.error("Error in handleSearchIssues:", error);
+    return handleError(error);
+  }
+}
+
+// src/tools/get-my-issues.ts
+var log6 = createLogger("tool:get-my-issues");
+var getMyIssuesTool = {
+  name: TOOL_NAMES.GET_MY_ISSUES,
+  description: "Retrieves issues assigned to current user, sorted by most recently updated first. Supports pagination and field selection.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      startAt: {
+        type: "number",
+        description: "Index of first result to return (for pagination)",
+        minimum: 0,
+        default: 0
+      },
+      maxResults: {
+        type: "number",
+        description: "Maximum number of results to return",
+        minimum: 1,
+        maximum: 100,
+        default: 50
+      },
+      fields: {
+        type: "array",
+        items: { type: "string" },
+        description: "Specific fields to retrieve for each issue"
+      },
+      expand: {
+        type: "array",
+        items: { type: "string" },
+        description: "Additional details to include for each issue",
+        default: []
+      }
+    },
+    required: []
+  }
+};
+async function handleGetMyIssues(input) {
+  try {
+    const validated = validateInput(GetMyIssuesInputSchema, input);
+    log6.info("Getting issues assigned to current user...");
+    const getParams = {};
+    if (validated.startAt !== void 0) getParams.startAt = validated.startAt;
+    if (validated.maxResults !== void 0) getParams.maxResults = validated.maxResults;
+    if (validated.fields !== void 0) getParams.fields = validated.fields;
+    if (validated.expand !== void 0) getParams.expand = validated.expand;
+    const result = await getMyIssues(getParams);
+    log6.info(`Found ${result.total} issue(s) assigned to you, showing ${result.issues.length}`);
+    return formatSearchResultsResponse(result);
+  } catch (error) {
+    log6.error("Error in handleGetMyIssues:", error);
+    return handleError(error);
+  }
+}
+
+// src/tools/get-issue-types.ts
+var log7 = createLogger("tool:get-issue-types");
+var getIssueTypesTool = {
+  name: TOOL_NAMES.GET_ISSUE_TYPES,
+  description: "Retrieves available issue types. Can get global issue types or project-specific issue types including regular issues and subtasks (Bug, Story, Task, Epic, etc.).",
+  inputSchema: {
+    type: "object",
+    properties: {
+      projectKey: {
+        type: "string",
+        description: "Project key to get issue types for specific project (optional - if not provided, returns global issue types)"
+      }
+    },
+    required: []
+  }
+};
+async function handleGetIssueTypes(input) {
+  try {
+    const validated = validateInput(GetIssueTypesInputSchema, input);
+    if (validated.projectKey) {
+      log7.info(`Getting issue types for project ${validated.projectKey}...`);
+    } else {
+      log7.info("Getting global issue types...");
+    }
+    const issueTypes = await getIssueTypes(validated.projectKey);
+    log7.info(`Found ${issueTypes.length} issue type(s)`);
+    return formatIssueTypesResponse(issueTypes);
+  } catch (error) {
+    log7.error("Error in handleGetIssueTypes:", error);
+    return handleError(error);
+  }
+}
+
+// src/tools/get-users.ts
+var log8 = createLogger("tool:get-users");
+var getUsersTool = {
+  name: TOOL_NAMES.GET_USERS,
+  description: "Search for users by name, email, username, or account ID. Returns display name, email, account status, and account type. Supports pagination.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      query: {
+        type: "string",
+        description: "Search query for user name or email (partial matches supported)"
+      },
+      username: {
+        type: "string",
+        description: "Specific username to search for"
+      },
+      accountId: {
+        type: "string",
+        description: "Specific account ID to search for"
+      },
+      startAt: {
+        type: "number",
+        description: "Index of first result to return (for pagination)",
+        minimum: 0,
+        default: 0
+      },
+      maxResults: {
+        type: "number",
+        description: "Maximum number of results to return",
+        minimum: 1,
+        maximum: 50,
+        default: 50
+      }
+    },
+    required: []
+  }
+};
+async function handleGetUsers(input) {
+  try {
+    const validated = validateInput(GetUsersInputSchema, input);
+    if (validated.query) {
+      log8.info(`Searching users with query: "${validated.query}"...`);
+    } else if (validated.username) {
+      log8.info(`Searching for username: "${validated.username}"...`);
+    } else if (validated.accountId) {
+      log8.info(`Searching for account ID: "${validated.accountId}"...`);
+    } else {
+      log8.info("Getting all users...");
+    }
+    const getParams = {};
+    if (validated.query !== void 0) getParams.query = validated.query;
+    if (validated.username !== void 0) getParams.username = validated.username;
+    if (validated.accountId !== void 0) getParams.accountId = validated.accountId;
+    if (validated.startAt !== void 0) getParams.startAt = validated.startAt;
+    if (validated.maxResults !== void 0) getParams.maxResults = validated.maxResults;
+    const users = await getUsers(getParams);
+    log8.info(`Found ${users.length} user(s)`);
+    return formatUsersResponse(users);
+  } catch (error) {
+    log8.error("Error in handleGetUsers:", error);
+    return handleError(error);
+  }
+}
+
+// src/tools/get-priorities.ts
+var log9 = createLogger("tool:get-priorities");
+var getPrioritiesTool = {
+  name: TOOL_NAMES.GET_PRIORITIES,
+  description: "Retrieves available priorities (e.g., Highest, High, Medium, Low, Lowest). Returns IDs, names, and descriptions.",
+  inputSchema: {
+    type: "object",
+    properties: {},
+    required: []
+  }
+};
+async function handleGetPriorities(input) {
+  try {
+    validateInput(GetPrioritiesInputSchema, input);
+    log9.info("Getting all priority levels...");
+    const priorities = await getPriorities();
+    log9.info(`Found ${priorities.length} priority level(s)`);
+    return formatPrioritiesResponse(priorities);
+  } catch (error) {
+    log9.error("Error in handleGetPriorities:", error);
+    return handleError(error);
+  }
+}
+
+// src/tools/get-statuses.ts
+var log10 = createLogger("tool:get-statuses");
+var getStatusesTool = {
+  name: TOOL_NAMES.GET_STATUSES,
+  description: "Retrieves available statuses (global or project-specific, e.g., To Do, In Progress, Done). Returns status categories and workflow information.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      projectKey: {
+        type: "string",
+        description: "Project key to get statuses for specific project (optional)"
+      },
+      issueTypeId: {
+        type: "string",
+        description: "Issue type ID to get statuses for specific issue type (requires projectKey)"
+      }
+    },
+    required: []
+  }
+};
+async function handleGetStatuses(input) {
+  try {
+    const validated = validateInput(GetStatusesInputSchema, input);
+    if (validated.projectKey && validated.issueTypeId) {
+      log10.info(
+        `Getting statuses for project ${validated.projectKey} and issue type ${validated.issueTypeId}...`
+      );
+    } else if (validated.projectKey) {
+      log10.info(`Getting statuses for project ${validated.projectKey}...`);
+    } else {
+      log10.info("Getting global statuses...");
+    }
+    const getParams = {};
+    if (validated.projectKey !== void 0) getParams.projectKey = validated.projectKey;
+    if (validated.issueTypeId !== void 0) getParams.issueTypeId = validated.issueTypeId;
+    const statuses = await getStatuses(getParams);
+    log10.info(`Found ${statuses.length} status(es)`);
+    return formatStatusesResponse(statuses);
+  } catch (error) {
+    log10.error("Error in handleGetStatuses:", error);
+    return handleError(error);
+  }
+}
+
+// src/tools/create-issue.ts
+var log11 = createLogger("tool:create-issue");
+var createIssueTool = {
+  name: TOOL_NAMES.CREATE_ISSUE,
+  description: "Creates a new Jira issue in the specified project. Supports setting issue type, priority, assignee, labels, and components. Returns the created issue with all details.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      projectKey: {
+        type: "string",
+        description: "Project key where the issue will be created"
+      },
+      summary: {
+        type: "string",
+        description: "Issue summary/title",
+        minLength: 1
+      },
+      description: {
+        type: "string",
+        description: "Detailed issue description (optional)"
+      },
+      issueType: {
+        type: "string",
+        description: "Issue type name (e.g., Bug, Story, Task, Epic)"
+      },
+      priority: {
+        type: "string",
+        description: "Issue priority name (e.g., High, Medium, Low) - optional"
+      },
+      assignee: {
+        type: "string",
+        description: "Assignee account ID (optional)"
+      },
+      labels: {
+        type: "array",
+        items: { type: "string" },
+        description: "Issue labels (optional)",
+        default: []
+      },
+      components: {
+        type: "array",
+        items: { type: "string" },
+        description: "Component names (optional)",
+        default: []
+      },
+      returnIssue: {
+        type: "boolean",
+        description: "If false, returns only the issue key without fetching full details",
+        default: true
+      }
+    },
+    required: ["projectKey", "summary", "issueType"]
+  }
+};
+async function handleCreateIssue(input) {
+  try {
+    const validated = validateInput(CreateIssueInputSchema, input);
+    log11.info(`Creating issue in project ${validated.projectKey}...`);
+    const createParams = {
+      projectKey: validated.projectKey,
+      summary: validated.summary,
+      issueType: validated.issueType
+    };
+    if (validated.description !== void 0) createParams.description = validated.description;
+    if (validated.priority !== void 0) createParams.priority = validated.priority;
+    if (validated.assignee !== void 0) createParams.assignee = validated.assignee;
+    if (validated.labels !== void 0) createParams.labels = validated.labels;
+    if (validated.components !== void 0) createParams.components = validated.components;
+    let issueOrKey;
+    if (validated.returnIssue === false) {
+      issueOrKey = await createIssue(createParams, { returnIssue: false });
+    } else {
+      issueOrKey = await createIssue(createParams);
+    }
+    if (validated.returnIssue === false) {
+      const key = typeof issueOrKey === "string" ? issueOrKey : issueOrKey.key;
+      log11.info(`Created issue ${key}`);
+      return formatSuccessResponse(`Issue created: ${key}`);
+    }
+    const issue = issueOrKey;
+    log11.info(`Created issue ${issue.key}`);
+    return formatIssueResponse(issue);
+  } catch (error) {
+    log11.error("Error in handleCreateIssue:", error);
+    return handleError(error);
+  }
+}
+
+// src/tools/update-issue.ts
+var log12 = createLogger("tool:update-issue");
+var updateIssueTool = {
+  name: TOOL_NAMES.UPDATE_ISSUE,
+  description: "Updates an existing Jira issue by its key. Supports updating summary, description, priority, assignee, labels, and components. Only specified fields will be updated.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      issueKey: {
+        type: "string",
+        description: "Issue key to update (e.g., PROJECT-123)"
+      },
+      summary: {
+        type: "string",
+        description: "New issue summary/title (optional)"
+      },
+      description: {
+        type: "string",
+        description: "New issue description (optional)"
+      },
+      priority: {
+        type: "string",
+        description: "New priority name (e.g., High, Medium, Low) - optional"
+      },
+      assignee: {
+        type: "string",
+        description: "New assignee account ID (optional, use null string to unassign)"
+      },
+      labels: {
+        type: "array",
+        items: { type: "string" },
+        description: "New labels array (replaces existing labels) - optional"
+      },
+      components: {
+        type: "array",
+        items: { type: "string" },
+        description: "New components array (replaces existing components) - optional"
+      },
+      returnIssue: {
+        type: "boolean",
+        description: "If false, returns a success message without fetching the updated issue",
+        default: true
+      }
+    },
+    required: ["issueKey"]
+  }
+};
+async function handleUpdateIssue(input) {
+  try {
+    const validated = validateInput(UpdateIssueInputSchema, input);
+    log12.info(`Updating issue ${validated.issueKey}...`);
+    const updateParams = {};
+    if (validated.summary !== void 0) updateParams.summary = validated.summary;
+    if (validated.description !== void 0) updateParams.description = validated.description;
+    if (validated.priority !== void 0) updateParams.priority = validated.priority;
+    if (validated.assignee !== void 0) updateParams.assignee = validated.assignee;
+    if (validated.labels !== void 0) updateParams.labels = validated.labels;
+    if (validated.components !== void 0) updateParams.components = validated.components;
+    await updateIssue(validated.issueKey, updateParams);
+    if (validated.returnIssue === false) {
+      log12.info(`Updated issue ${validated.issueKey}`);
+      return formatSuccessResponse(`Issue ${validated.issueKey} updated successfully`);
+    }
+    const updatedIssue = await getIssue(validated.issueKey);
+    log12.info(`Updated issue ${updatedIssue.key}`);
+    return formatIssueResponse(updatedIssue);
+  } catch (error) {
+    log12.error("Error in handleUpdateIssue:", error);
+    return handleError(error);
+  }
+}
+
+// src/tools/add-comment.ts
+var log13 = createLogger("tool:add-comment");
+var addCommentTool = {
+  name: TOOL_NAMES.ADD_COMMENT,
+  description: "Adds a comment to an issue. Supports visibility restrictions for groups or roles. Returns the created comment with author details and timestamp.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      issueKey: {
+        type: "string",
+        description: "Issue key to add comment to (e.g., PROJECT-123)"
+      },
+      body: {
+        type: "string",
+        description: "Comment body text",
+        minLength: 1
+      },
+      visibility: {
+        type: "object",
+        description: "Comment visibility restrictions (optional)",
+        properties: {
+          type: {
+            type: "string",
+            enum: ["group", "role"],
+            description: 'Visibility type - either "group" or "role"'
+          },
+          value: {
+            type: "string",
+            description: "Group name or role name for visibility restriction"
+          }
+        },
+        required: ["type", "value"]
+      }
+    },
+    required: ["issueKey", "body"]
+  }
+};
+async function handleAddComment(input) {
+  try {
+    const validated = validateInput(AddCommentInputSchema, input);
+    log13.info(`Adding comment to issue ${validated.issueKey}...`);
+    const comment = await addComment(validated.issueKey, validated.body, validated.visibility);
+    log13.info(`Added comment to ${validated.issueKey}`);
+    return formatCommentResponse(comment);
+  } catch (error) {
+    log13.error("Error in handleAddComment:", error);
+    return handleError(error);
+  }
+}
+
+// src/tools/get-project-info.ts
+var log14 = createLogger("tool:get-project-info");
+var getProjectInfoTool = {
+  name: TOOL_NAMES.GET_PROJECT_INFO,
+  description: "Retrieves detailed information about a project (components, versions, issue types, roles, insights). More comprehensive than the basic project list.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      projectKey: {
+        type: "string",
+        description: "Project key to get detailed information for"
+      },
+      expand: {
+        type: "array",
+        items: { type: "string" },
+        description: 'Additional project details to include (e.g., ["description", "lead", "issueTypes", "versions"])',
+        default: []
+      }
+    },
+    required: ["projectKey"]
+  }
+};
+async function handleGetProjectInfo(input) {
+  try {
+    const validated = validateInput(GetProjectInfoInputSchema, input);
+    log14.info(`Getting detailed project information for ${validated.projectKey}...`);
+    const project = await getProjectDetails(validated.projectKey, validated.expand);
+    log14.info(`Retrieved project details for ${project.key}`);
+    return formatProjectDetailsResponse(project);
+  } catch (error) {
+    log14.error("Error in handleGetProjectInfo:", error);
+    return handleError(error);
+  }
+}
+
+// src/tools/create-subtask.ts
+var log15 = createLogger("tool:create-subtask");
+var createSubtaskTool = {
+  name: TOOL_NAMES.CREATE_SUBTASK,
+  description: "Creates a subtask under an existing parent issue. Automatically determines the correct project and subtask issue type. Supports setting priority, assignee, labels, and components.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      parentIssueKey: {
+        type: "string",
+        description: "Parent issue key (e.g., PROJECT-123)"
+      },
+      summary: {
+        type: "string",
+        description: "Subtask summary/title",
+        minLength: 1
+      },
+      description: {
+        type: "string",
+        description: "Detailed subtask description (optional)"
+      },
+      priority: {
+        type: "string",
+        description: "Subtask priority name (e.g., High, Medium, Low) - optional"
+      },
+      assignee: {
+        type: "string",
+        description: "Assignee account ID (optional)"
+      },
+      labels: {
+        type: "array",
+        items: { type: "string" },
+        description: "Subtask labels (optional)",
+        default: []
+      },
+      components: {
+        type: "array",
+        items: { type: "string" },
+        description: "Component names (optional)",
+        default: []
+      }
+    },
+    required: ["parentIssueKey", "summary"]
+  }
+};
+async function handleCreateSubtask(input) {
+  try {
+    const validated = validateInput(CreateSubtaskInputSchema, input);
+    log15.info(`Creating subtask under parent issue ${validated.parentIssueKey}...`);
+    const subtaskParams = {
+      summary: validated.summary
+    };
+    if (validated.description !== void 0) subtaskParams.description = validated.description;
+    if (validated.priority !== void 0) subtaskParams.priority = validated.priority;
+    if (validated.assignee !== void 0) subtaskParams.assignee = validated.assignee;
+    if (validated.labels !== void 0) subtaskParams.labels = validated.labels;
+    if (validated.components !== void 0) subtaskParams.components = validated.components;
+    const subtask = await createSubtask(validated.parentIssueKey, subtaskParams);
+    log15.info(`Created subtask ${subtask.key}`);
+    return formatIssueResponse(subtask);
+  } catch (error) {
+    log15.error("Error in handleCreateSubtask:", error);
+    return handleError(error);
+  }
+}
+
+// src/index.ts
+if (process.env.NODE_ENV !== "production") {
+  try {
+    const { config } = await Promise.resolve().then(() => __toESM(require_main(), 1));
+    config();
+  } catch {
+  }
+}
+var log16 = createLogger("server");
+var toolHandlers = /* @__PURE__ */ new Map([
+  [TOOL_NAMES.GET_VISIBLE_PROJECTS, handleGetVisibleProjects],
+  [TOOL_NAMES.GET_ISSUE, handleGetIssue],
+  [TOOL_NAMES.SEARCH_ISSUES, handleSearchIssues],
+  [TOOL_NAMES.GET_MY_ISSUES, handleGetMyIssues],
+  [TOOL_NAMES.GET_ISSUE_TYPES, handleGetIssueTypes],
+  [TOOL_NAMES.GET_USERS, handleGetUsers],
+  [TOOL_NAMES.GET_PRIORITIES, handleGetPriorities],
+  [TOOL_NAMES.GET_STATUSES, handleGetStatuses],
+  [TOOL_NAMES.CREATE_ISSUE, handleCreateIssue],
+  [TOOL_NAMES.UPDATE_ISSUE, handleUpdateIssue],
+  [TOOL_NAMES.ADD_COMMENT, handleAddComment],
+  [TOOL_NAMES.GET_PROJECT_INFO, handleGetProjectInfo],
+  [TOOL_NAMES.CREATE_SUBTASK, handleCreateSubtask]
+]);
+var allTools = [
+  getVisibleProjectsTool,
+  getIssueTool,
+  searchIssuesTool,
+  getMyIssuesTool,
+  getIssueTypesTool,
+  getUsersTool,
+  getPrioritiesTool,
+  getStatusesTool,
+  createIssueTool,
+  updateIssueTool,
+  addCommentTool,
+  getProjectInfoTool,
+  createSubtaskTool
+];
+async function main() {
+  try {
+    const auth = validateAuth();
+    console.error(`\u{1F510} Authenticated as: ${auth.email}`);
+    console.error(`\u{1F310} Jira instance: ${auth.baseUrl}`);
+    console.error("\u{1F50D} Testing connection to Jira...");
+    const ok = await testConnection();
+    if (!ok) {
+      console.error("\u274C Connection to Jira failed");
+      process.exit(1);
+      return;
+    }
+    console.error("\u2705 Connection to Jira successful");
+  } catch (error) {
+    console.error("\u274C Authentication Error:", error.message);
+    process.exit(1);
+    return;
+  }
+  let version = "0.0.0";
+  try {
+    const pkg = await Promise.resolve().then(() => __toESM(require_package2(), 1));
+    version = pkg.default?.version || pkg.version || version;
+  } catch {
+  }
+  const server = new Server(
+    {
+      name: "jira-mcp-server",
+      version
+    },
+    {
+      capabilities: {
+        resources: {},
+        tools: {}
+      }
+    }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    console.error(`\u{1F4CB} Listing ${allTools.length} available tool(s)`);
+    return { tools: allTools };
+  });
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    console.error(`\u{1F6E0}\uFE0F Executing tool: ${name}`);
+    const handler = toolHandlers.get(name);
+    if (!handler) {
+      throw new Error(`Unknown tool: ${name}`);
+    }
+    try {
+      const result = await handler(args);
+      console.error(`\u2705 Tool ${name} executed successfully`);
+      return result;
+    } catch (error) {
+      console.error(`\u274C Error executing tool ${name}:`, error.message);
+      throw error;
+    }
+  });
+  server.setRequestHandler(ListResourcesRequestSchema, async () => {
+    return { resources: [] };
+  });
+  server.setRequestHandler(ReadResourceRequestSchema, async () => {
+    throw new Error("Resource reading not implemented");
+  });
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("\u{1F680} Jira MCP server running on stdio");
+}
+main().catch((error) => {
+  log16.error("Fatal error:", error);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map