lastgen-cli 1.0.0

package/dist/chunk-JGVBNMNK.js

@@ -0,0 +1,257 @@
+#!/usr/bin/env node
+
+// src/api.ts
+import { readFileSync } from "fs";
+import { Agent } from "undici";
+var ApiError = class extends Error {
+  status;
+  constructor(message, status) {
+    super(message);
+    this.name = "ApiError";
+    this.status = status;
+  }
+};
+function normalizeBaseUrl(baseUrl) {
+  return baseUrl.replace(/\/+$/, "");
+}
+function describeHttpError(status, body) {
+  switch (status) {
+    case 401:
+      return "API anahtar\u0131 ge\xE7ersiz veya eksik (401).";
+    case 403:
+      return "Eri\u015Fim reddedildi (403).";
+    case 404:
+      return "Endpoint bulunamad\u0131 \u2014 base URL yanl\u0131\u015F olabilir (404).";
+    case 429:
+      return "H\u0131z s\u0131n\u0131r\u0131 a\u015F\u0131ld\u0131 (429). Biraz bekleyip tekrar deneyin.";
+    default:
+      if (status >= 500) return `Sunucu hatas\u0131 (${status}).`;
+      return `\u0130stek ba\u015Far\u0131s\u0131z (${status})${body ? ": " + body : ""}.`;
+  }
+}
+function extractDelta(data) {
+  if (data === "[DONE]") return null;
+  try {
+    const json = JSON.parse(data);
+    const delta = json?.choices?.[0]?.delta;
+    const content = delta?.content;
+    if (typeof content === "string" && content.length > 0) {
+      return { type: "content", text: content };
+    }
+    const reasoning = delta?.reasoning_content;
+    if (typeof reasoning === "string" && reasoning.length > 0) {
+      return { type: "reasoning", text: reasoning };
+    }
+    const usage = json?.usage;
+    if (usage && typeof usage.total_tokens === "number") {
+      return {
+        type: "usage",
+        text: "",
+        usage: {
+          promptTokens: usage.prompt_tokens ?? 0,
+          completionTokens: usage.completion_tokens ?? 0,
+          totalTokens: usage.total_tokens
+        }
+      };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function connectErrorMessage(err, url) {
+  const e = err;
+  const name = e?.name;
+  const code = e?.cause?.code;
+  if (name === "TimeoutError") {
+    return "Zaman a\u015F\u0131m\u0131: sunucu yan\u0131t vermedi (30s). Endpoint/a\u011F eri\u015Fimini ve VPN'i kontrol edin.";
+  }
+  if (code === "ENOTFOUND" || code === "EAI_AGAIN") {
+    return `Adres \xE7\xF6z\xFClemedi (${url}). \u0130\xE7 a\u011F/VPN ba\u011Flant\u0131n\u0131z\u0131 ve endpoint adresini kontrol edin.`;
+  }
+  if (code === "ECONNREFUSED") {
+    return `Ba\u011Flant\u0131 reddedildi (${url}). Sunucu \xE7al\u0131\u015F\u0131yor mu ve port do\u011Fru mu?`;
+  }
+  if (code === "DEPTH_ZERO_SELF_SIGNED_CERT" || code === "SELF_SIGNED_CERT_IN_CHAIN") {
+    return "Sertifika do\u011Frulanamad\u0131 (self-signed). config'te verifySsl: false yap\u0131n veya caBundlePath verin.";
+  }
+  return `Ba\u011Flant\u0131 kurulamad\u0131: ${e?.message ?? String(err)}${code ? ` (${code})` : ""}`;
+}
+function isRetriableConnError(err) {
+  const e = err;
+  const code = e?.cause?.code ?? e?.code;
+  return code === "ECONNRESET" || code === "UND_ERR_SOCKET" || code === "EPIPE" || code === "ECONNABORTED";
+}
+async function fetchWithRetry(url, init) {
+  try {
+    return await fetch(url, init);
+  } catch (err) {
+    if (!isRetriableConnError(err)) throw err;
+    return await fetch(url, init);
+  }
+}
+async function safeText(res) {
+  try {
+    return (await res.text()).slice(0, 200);
+  } catch {
+    return "";
+  }
+}
+function authHeaders(config) {
+  return { Authorization: `Bearer ${config.apiKey}` };
+}
+var cachedDispatcher;
+var cachedKey;
+function getDispatcher(config) {
+  const insecure = config.verifySsl === false;
+  const useCa = !insecure && Boolean(config.caBundlePath);
+  if (!insecure && !useCa) return void 0;
+  const key = `${insecure}|${useCa ? config.caBundlePath : ""}`;
+  if (cachedDispatcher && cachedKey === key) return cachedDispatcher;
+  const connect = {};
+  if (insecure) connect.rejectUnauthorized = false;
+  if (useCa) {
+    try {
+      connect.ca = readFileSync(config.caBundlePath, "utf8");
+    } catch (err) {
+      throw new ApiError(
+        `CA dosyas\u0131 okunamad\u0131 (${config.caBundlePath}): ${err.message}`
+      );
+    }
+  }
+  cachedDispatcher = new Agent({ connect });
+  cachedKey = key;
+  return cachedDispatcher;
+}
+function withDispatcher(config, init) {
+  const dispatcher = getDispatcher(config);
+  if (!dispatcher) return init;
+  return { ...init, dispatcher };
+}
+async function listModels(config) {
+  const url = `${normalizeBaseUrl(config.baseUrl)}/models`;
+  let res;
+  try {
+    res = await fetchWithRetry(
+      url,
+      withDispatcher(config, {
+        headers: authHeaders(config),
+        signal: AbortSignal.timeout(3e4)
+      })
+    );
+  } catch (err) {
+    throw new ApiError(connectErrorMessage(err, url));
+  }
+  if (!res.ok) {
+    throw new ApiError(describeHttpError(res.status, await safeText(res)), res.status);
+  }
+  const data = await res.json();
+  const list = Array.isArray(data?.data) ? data.data : [];
+  return list.map((m) => m.id).filter((id) => Boolean(id)).sort();
+}
+async function* streamChat(config, messages, signal) {
+  const url = `${normalizeBaseUrl(config.baseUrl)}/chat/completions`;
+  let res;
+  try {
+    res = await fetchWithRetry(
+      url,
+      withDispatcher(config, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...authHeaders(config)
+        },
+        body: JSON.stringify({
+          model: config.model,
+          messages,
+          stream: true,
+          stream_options: { include_usage: true }
+        }),
+        ...signal ? { signal } : {}
+      })
+    );
+  } catch (err) {
+    throw new ApiError(connectErrorMessage(err, url));
+  }
+  if (!res.ok) {
+    throw new ApiError(describeHttpError(res.status, await safeText(res)), res.status);
+  }
+  if (!res.body) throw new ApiError("Yan\u0131t g\xF6vdesi bo\u015F.");
+  yield* parseSSE(res.body);
+}
+function isTransientError(err) {
+  const e = err;
+  if (e?.name === "AbortError") return true;
+  if (err instanceof ApiError) {
+    if (err.status === void 0) return true;
+    return err.status >= 500 || err.status === 429;
+  }
+  return true;
+}
+var TTFB_TIMEOUT_MS = 3e4;
+var RATE_LIMIT_BACKOFFS = [8e3, 16e3, 32e3, 64e3];
+async function* streamChatWithRetry(config, messages, attempts = 4, backoffMs = 1e3, onRetry) {
+  let lastErr;
+  for (let attempt = 1; attempt <= attempts; attempt++) {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), TTFB_TIMEOUT_MS);
+    let yielded = false;
+    try {
+      for await (const ev of streamChat(config, messages, ctrl.signal)) {
+        if (!yielded) {
+          yielded = true;
+          clearTimeout(timer);
+        }
+        yield ev;
+      }
+      clearTimeout(timer);
+      return;
+    } catch (err) {
+      clearTimeout(timer);
+      const e = ctrl.signal.aborted ? new ApiError("Sunucu zaman\u0131nda yan\u0131t vermedi (timeout).") : err;
+      lastErr = e;
+      if (yielded || !isTransientError(e)) throw e;
+      if (attempt < attempts) {
+        const is429 = e instanceof ApiError && e.status === 429;
+        const wait = is429 ? RATE_LIMIT_BACKOFFS[attempt - 1] ?? 64e3 : backoffMs * attempt;
+        onRetry?.(attempt, wait, is429);
+        await new Promise((r) => setTimeout(r, wait));
+      }
+    }
+  }
+  throw lastErr;
+}
+async function* parseSSE(body) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      let idx;
+      while ((idx = buffer.indexOf("\n")) !== -1) {
+        const line = buffer.slice(0, idx).trim();
+        buffer = buffer.slice(idx + 1);
+        if (!line.startsWith("data:")) continue;
+        const data = line.slice(5).trim();
+        if (data === "[DONE]") return;
+        const ev = extractDelta(data);
+        if (ev) yield ev;
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+export {
+  ApiError,
+  describeHttpError,
+  connectErrorMessage,
+  getDispatcher,
+  listModels,
+  streamChat,
+  streamChatWithRetry
+};

package/dist/chunk-JUKR4XSW.js

@@ -0,0 +1,283 @@
+#!/usr/bin/env node
+import {
+  ApiError,
+  connectErrorMessage,
+  describeHttpError,
+  getDispatcher
+} from "./chunk-JGVBNMNK.js";
+
+// src/trello.ts
+import { stdin, stdout } from "process";
+import chalk from "chalk";
+var SHORT_LINK_RE = /^[a-zA-Z0-9]{8}$/;
+function extractCardId(input) {
+  const s = input.trim();
+  const urlMatch = s.match(/\/c\/([a-zA-Z0-9]{8})(?:\/|$)/);
+  if (urlMatch) return urlMatch[1];
+  if (SHORT_LINK_RE.test(s)) return s;
+  throw new ApiError(`Ge\xE7erli bir Trello kart ID'si bulunamad\u0131: "${input}". \xD6rnek: AbCdEfGh veya .../c/AbCdEfGh/...`);
+}
+function describeTrelloError(status) {
+  switch (status) {
+    case 401:
+      return "Trello kimlik do\u011Frulamas\u0131 ba\u015Far\u0131s\u0131z (401). /trello-login ile yenileyin.";
+    case 404:
+      return "Trello kart\u0131 bulunamad\u0131 veya eri\u015Fim yetkiniz yok (404).";
+    default:
+      return describeHttpError(status);
+  }
+}
+function trelloUrl(path, config) {
+  if (!config.trelloKey || !config.trelloToken) {
+    throw new ApiError("Trello yap\u0131land\u0131rmas\u0131 yok. \xD6nce /trello-login yap\u0131n.");
+  }
+  return `https://api.trello.com${path}?key=${encodeURIComponent(config.trelloKey)}&token=${encodeURIComponent(config.trelloToken)}`;
+}
+function trelloInit(config) {
+  const dispatcher = getDispatcher(config);
+  const base = { signal: AbortSignal.timeout(15e3) };
+  if (!dispatcher) return base;
+  return { ...base, dispatcher };
+}
+async function fetchListName(config, idList) {
+  try {
+    const url = trelloUrl(`/1/lists/${encodeURIComponent(idList)}`, config) + "&fields=name";
+    const res = await fetch(url, trelloInit(config));
+    if (!res.ok) return "(liste bilinmiyor)";
+    const data = await res.json();
+    return data.name ?? "(liste bilinmiyor)";
+  } catch {
+    return "(liste bilinmiyor)";
+  }
+}
+async function fetchCard(config, cardId) {
+  const url = trelloUrl(`/1/cards/${encodeURIComponent(cardId)}`, config) + "&fields=name,desc,idList,labels,shortLink,url";
+  let res;
+  try {
+    res = await fetch(url, trelloInit(config));
+  } catch (err) {
+    throw new ApiError(connectErrorMessage(err, url));
+  }
+  if (!res.ok) throw new ApiError(describeTrelloError(res.status), res.status);
+  const data = await res.json();
+  const listName = data.idList ? await fetchListName(config, data.idList) : "(liste bilinmiyor)";
+  const labels = (data.labels ?? []).map((l) => l.name ?? l.color ?? "").filter(Boolean);
+  return {
+    id: data.shortLink ?? cardId,
+    shortLink: data.shortLink ?? cardId,
+    name: data.name ?? "(ba\u015Fl\u0131k yok)",
+    desc: data.desc ?? "",
+    listName,
+    labels
+  };
+}
+async function fetchBoards(config) {
+  const url = trelloUrl("/1/members/me/boards", config) + "&fields=name,url&filter=open";
+  let res;
+  try {
+    res = await fetch(url, trelloInit(config));
+  } catch (err) {
+    throw new ApiError(connectErrorMessage(err, url));
+  }
+  if (!res.ok) throw new ApiError(describeTrelloError(res.status), res.status);
+  const data = await res.json();
+  return data.map((b) => ({ id: b.id, name: b.name, url: b.url }));
+}
+var TRELLO_BACK = /* @__PURE__ */ Symbol("TRELLO_BACK");
+async function runTrelloBoardPicker(boards, initialSel = 0) {
+  if (boards.length === 0) return null;
+  if (!stdin.isTTY || !stdout.isTTY) return boards[0];
+  const brand = chalk.hex("#1577d4").bold;
+  const dim = chalk.dim;
+  const hi = chalk.white.bold;
+  const hiNum = chalk.greenBright.bold;
+  function draw(sel) {
+    const R = stdout.rows || 24;
+    const lines = [];
+    lines.push("");
+    lines.push("  " + brand("Trello") + dim("  \u2014  pano se\xE7"));
+    lines.push("");
+    boards.forEach((b, i) => {
+      const selected = i === sel;
+      lines.push(
+        (selected ? hiNum(`  \u203A ${i + 1}.`) : dim(`    ${i + 1}.`)) + "  " + (selected ? hi(b.name) : chalk.white(b.name))
+      );
+    });
+    lines.push("");
+    lines.push(dim("  \u2191 \u2193 gezin   Enter se\xE7   Ctrl+C iptal"));
+    lines.push("");
+    let buf = "\x1B[?25l\x1B[H";
+    for (let r = 0; r < R; r++) buf += `\x1B[${r + 1};1H\x1B[2K` + (lines[r] ?? "");
+    stdout.write(buf);
+  }
+  return new Promise((resolve) => {
+    let sel = Math.max(0, Math.min(initialSel, boards.length - 1));
+    const wasRaw = Boolean(stdin.isRaw);
+    const cleanup = () => {
+      stdin.removeListener("data", onData);
+      stdin.setRawMode(wasRaw);
+      if (!wasRaw) stdin.pause();
+      stdout.write("\x1B[?25h\x1B[2J\x1B[H");
+    };
+    const onData = (chunk) => {
+      const code = chunk.charCodeAt(0);
+      if (code === 3) {
+        cleanup();
+        resolve(null);
+        return;
+      }
+      if (code === 27 && chunk.length === 1) {
+        cleanup();
+        resolve(null);
+        return;
+      }
+      if (chunk === "\x1B[A") {
+        sel = sel > 0 ? sel - 1 : boards.length - 1;
+        draw(sel);
+        return;
+      }
+      if (chunk === "\x1B[B") {
+        sel = sel < boards.length - 1 ? sel + 1 : 0;
+        draw(sel);
+        return;
+      }
+      if (chunk === "\r" || chunk === "\n") {
+        cleanup();
+        resolve(boards[sel]);
+      }
+    };
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    stdin.on("data", onData);
+    draw(sel);
+  });
+}
+async function fetchBoardCards(config, boardId) {
+  const url = trelloUrl(`/1/boards/${encodeURIComponent(boardId)}/cards`, config) + "&fields=name,shortLink,idList&filter=open";
+  let res;
+  try {
+    res = await fetch(url, trelloInit(config));
+  } catch (err) {
+    throw new ApiError(connectErrorMessage(err, url));
+  }
+  if (!res.ok) throw new ApiError(describeTrelloError(res.status), res.status);
+  const data = await res.json();
+  const listIds = [...new Set(data.map((c) => c.idList))];
+  const listNames = /* @__PURE__ */ new Map();
+  await Promise.all(listIds.map(async (id) => {
+    listNames.set(id, await fetchListName(config, id));
+  }));
+  return data.map((c) => ({
+    shortLink: c.shortLink,
+    name: c.name,
+    listName: listNames.get(c.idList) ?? "(liste bilinmiyor)"
+  }));
+}
+async function runTrelloCardPicker(cards, boardName) {
+  if (cards.length === 0) return TRELLO_BACK;
+  if (!stdin.isTTY || !stdout.isTTY) return cards[0];
+  const brand = chalk.hex("#1577d4").bold;
+  const dim = chalk.dim;
+  const hi = chalk.white.bold;
+  const hiNum = chalk.greenBright.bold;
+  function draw(sel, offset) {
+    const R = stdout.rows || 24;
+    const C = stdout.columns || 80;
+    const maxVisible = Math.max(1, R - 6);
+    const lines = [];
+    lines.push("");
+    lines.push("  " + brand("Trello") + dim(`  \u2014  ${boardName}  \u2014  kart se\xE7`));
+    lines.push("");
+    const visible = cards.slice(offset, offset + maxVisible);
+    visible.forEach((c, vi) => {
+      const i = vi + offset;
+      const selected = i === sel;
+      const list = dim(`[${c.listName}] `);
+      const title = c.name.slice(0, C - 20);
+      lines.push(
+        (selected ? hiNum(`  \u203A ${i + 1}.`) : dim(`    ${i + 1}.`)) + "  " + list + (selected ? hi(title) : chalk.white(title))
+      );
+    });
+    lines.push("");
+    lines.push(dim("  \u2191 \u2193 gezin   Enter se\xE7   ESC panolara d\xF6n   Ctrl+C iptal"));
+    lines.push("");
+    let buf = "\x1B[?25l\x1B[H";
+    for (let r = 0; r < R; r++) buf += `\x1B[${r + 1};1H\x1B[2K` + (lines[r] ?? "");
+    stdout.write(buf);
+  }
+  return new Promise((resolve) => {
+    let sel = 0;
+    let offset = 0;
+    const wasRaw = Boolean(stdin.isRaw);
+    const maxVisible = Math.max(1, (stdout.rows || 24) - 6);
+    const cleanup = () => {
+      stdin.removeListener("data", onData);
+      stdin.setRawMode(wasRaw);
+      if (!wasRaw) stdin.pause();
+      stdout.write("\x1B[?25h\x1B[2J\x1B[H");
+    };
+    const onData = (chunk) => {
+      const code = chunk.charCodeAt(0);
+      if (code === 3) {
+        cleanup();
+        resolve(null);
+        return;
+      }
+      if (code === 27 && chunk.length === 1) {
+        cleanup();
+        resolve(TRELLO_BACK);
+        return;
+      }
+      if (chunk === "\x1B[A") {
+        if (sel > 0) {
+          sel--;
+          if (sel < offset) offset = sel;
+        }
+        draw(sel, offset);
+        return;
+      }
+      if (chunk === "\x1B[B") {
+        if (sel < cards.length - 1) {
+          sel++;
+          if (sel >= offset + maxVisible) offset = sel - maxVisible + 1;
+        }
+        draw(sel, offset);
+        return;
+      }
+      if (chunk === "\r" || chunk === "\n") {
+        cleanup();
+        resolve(cards[sel]);
+      }
+    };
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    stdin.on("data", onData);
+    draw(sel, offset);
+  });
+}
+async function validateTrelloAuth(config) {
+  const url = trelloUrl("/1/members/me", config) + "&fields=fullName,username";
+  let res;
+  try {
+    res = await fetch(url, trelloInit(config));
+  } catch (err) {
+    throw new ApiError(connectErrorMessage(err, url));
+  }
+  if (!res.ok) throw new ApiError(describeTrelloError(res.status), res.status);
+  const data = await res.json();
+  return data.fullName ?? data.username ?? "(bilinmeyen kullan\u0131c\u0131)";
+}
+
+export {
+  extractCardId,
+  describeTrelloError,
+  fetchCard,
+  fetchBoards,
+  TRELLO_BACK,
+  runTrelloBoardPicker,
+  fetchBoardCards,
+  runTrelloCardPicker,
+  validateTrelloAuth
+};

package/dist/chunk-NILKRTZZ.js

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+import {
+  ApiError,
+  connectErrorMessage,
+  describeHttpError,
+  getDispatcher
+} from "./chunk-JGVBNMNK.js";
+
+// src/jira.ts
+var KEY = "[A-Z][A-Z0-9]+-\\d+";
+function extractIssueKey(input) {
+  const s = input.trim();
+  const browse = s.match(new RegExp(`/browse/(${KEY})`, "i"));
+  if (browse) return browse[1].toUpperCase();
+  const selected = s.match(new RegExp(`[?&]selectedIssue=(${KEY})`, "i"));
+  if (selected) return selected[1].toUpperCase();
+  const bare = s.match(new RegExp(`^(${KEY})$`));
+  if (bare) return bare[1].toUpperCase();
+  const all = s.match(new RegExp(`(${KEY})`, "g"));
+  if (all && all.length > 0) return all[all.length - 1].toUpperCase();
+  throw new ApiError(
+    `Ge\xE7erli bir Jira issue key bulunamad\u0131: "${input}". \xD6rnek: PROJ-1234 veya .../browse/PROJ-1234`
+  );
+}
+function describeJiraError(status, key) {
+  switch (status) {
+    case 401:
+      return "Jira PAT ge\xE7ersiz veya s\xFCresi dolmu\u015F (401). /jira-login ile yenileyin.";
+    case 403:
+      return "Jira eri\u015Fimi reddedildi (403). Token yetkilerini kontrol edin.";
+    case 404:
+      return `Issue bulunamad\u0131 veya eri\u015Fim yetkiniz yok: ${key} (404).`;
+    default:
+      return describeHttpError(status);
+  }
+}
+function adfToText(node, depth = 0) {
+  if (typeof node === "string") return node;
+  if (!node || typeof node !== "object") return "";
+  const n = node;
+  if (n.type === "text") return typeof n.text === "string" ? n.text : "";
+  const children = Array.isArray(n.content) ? n.content.map((c) => adfToText(c, depth + 1)).join("") : "";
+  const block = ["paragraph", "heading", "bulletList", "orderedList", "listItem", "blockquote", "codeBlock", "rule"];
+  return block.includes(n.type) ? children + "\n" : children;
+}
+function extractDescription(raw) {
+  if (typeof raw === "string") return raw;
+  if (raw && typeof raw === "object") return adfToText(raw).trim();
+  return "";
+}
+function jiraBase(config) {
+  if (!config.jiraBaseUrl || !config.jiraToken) {
+    throw new ApiError("Jira yap\u0131land\u0131rmas\u0131 yok. \xD6nce /jira-login yap\u0131n.");
+  }
+  return config.jiraBaseUrl.replace(/\/+$/, "");
+}
+function jiraInit(config, init) {
+  const headers = {
+    Authorization: `Bearer ${config.jiraToken}`,
+    Accept: "application/json",
+    ...init.headers ?? {}
+  };
+  const dispatcher = getDispatcher(config);
+  const base = { ...init, headers, signal: AbortSignal.timeout(3e4) };
+  if (!dispatcher) return base;
+  return { ...base, dispatcher };
+}
+async function fetchIssue(config, key) {
+  const url = `${jiraBase(config)}/rest/api/2/issue/${encodeURIComponent(key)}?fields=summary,description,issuetype`;
+  let res;
+  try {
+    res = await fetch(url, jiraInit(config, {}));
+  } catch (err) {
+    throw new ApiError(connectErrorMessage(err, url));
+  }
+  if (!res.ok) {
+    throw new ApiError(describeJiraError(res.status, key), res.status);
+  }
+  const data = await res.json();
+  const f = data.fields ?? {};
+  return {
+    key,
+    summary: f.summary ?? "(ba\u015Fl\u0131k yok)",
+    description: extractDescription(f.description),
+    issueType: f.issuetype?.name ?? "Task"
+  };
+}
+async function validateAuth(config) {
+  const url = `${jiraBase(config)}/rest/api/2/myself`;
+  let res;
+  try {
+    res = await fetch(url, jiraInit(config, {}));
+  } catch (err) {
+    throw new ApiError(connectErrorMessage(err, url));
+  }
+  if (!res.ok) {
+    throw new ApiError(describeJiraError(res.status, "(myself)"), res.status);
+  }
+  const data = await res.json();
+  return data.displayName ?? data.name ?? "(bilinmeyen kullan\u0131c\u0131)";
+}
+
+export {
+  extractIssueKey,
+  describeJiraError,
+  fetchIssue,
+  validateAuth
+};