@iloom/cli 0.9.2 → 0.10.0

package/dist/chunk-HEXKPKCK.js

@@ -0,0 +1,1396 @@
+#!/usr/bin/env node
+import {
+  getLogger
+} from "./chunk-6MLEBAYZ.js";
+import {
+  promptConfirmation
+} from "./chunk-7JDMYTFZ.js";
+import {
+  logger
+} from "./chunk-VT4PDUYT.js";
+
+// src/utils/linear.ts
+import { LinearClient, IssueRelationType } from "@linear/sdk";
+
+// src/types/linear.ts
+var LinearServiceError = class _LinearServiceError extends Error {
+  constructor(code, message, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "LinearServiceError";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _LinearServiceError);
+    }
+  }
+};
+
+// src/utils/linear.ts
+function slugifyTitle(title, maxLength = 50) {
+  const slug = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  if (slug.length <= maxLength) {
+    return slug;
+  }
+  const parts = slug.split("-");
+  let result = "";
+  for (const part of parts) {
+    const candidate = result ? `${result}-${part}` : part;
+    if (candidate.length > maxLength) {
+      break;
+    }
+    result = candidate;
+  }
+  return result || slug.slice(0, maxLength);
+}
+function buildLinearIssueUrl(identifier, title) {
+  const base = `https://linear.app/issue/${identifier}`;
+  if (title) {
+    const slug = slugifyTitle(title);
+    return slug ? `${base}/${slug}` : base;
+  }
+  return base;
+}
+function getLinearApiToken() {
+  const token = process.env.LINEAR_API_TOKEN;
+  if (!token) {
+    throw new LinearServiceError(
+      "UNAUTHORIZED",
+      "LINEAR_API_TOKEN not set. Configure in settings.local.json or set environment variable."
+    );
+  }
+  return token;
+}
+function createLinearClient(apiToken) {
+  const token = apiToken ?? getLinearApiToken();
+  return new LinearClient({ apiKey: token });
+}
+function handleLinearError(error, context) {
+  logger.debug(`${context}: Handling error`, { error });
+  const errorMessage = error instanceof Error ? error.message : String(error);
+  if (errorMessage.includes("not found") || errorMessage.includes("Not found")) {
+    throw new LinearServiceError("NOT_FOUND", "Linear issue or resource not found", { error });
+  }
+  if (errorMessage.includes("unauthorized") || errorMessage.includes("Unauthorized") || errorMessage.includes("Invalid API key")) {
+    throw new LinearServiceError(
+      "UNAUTHORIZED",
+      "Linear authentication failed. Check LINEAR_API_TOKEN.",
+      { error }
+    );
+  }
+  if (errorMessage.includes("rate limit")) {
+    throw new LinearServiceError("RATE_LIMITED", "Linear API rate limit exceeded", { error });
+  }
+  throw new LinearServiceError("CLI_ERROR", `Linear SDK error: ${errorMessage}`, { error });
+}
+async function fetchLinearIssue(identifier) {
+  try {
+    logger.debug(`Fetching Linear issue: ${identifier}`);
+    const client = createLinearClient();
+    const issue = await client.issue(identifier);
+    if (!issue) {
+      throw new LinearServiceError("NOT_FOUND", `Linear issue ${identifier} not found`);
+    }
+    const result = {
+      id: issue.id,
+      identifier: issue.identifier,
+      title: issue.title,
+      url: issue.url,
+      createdAt: issue.createdAt.toISOString(),
+      updatedAt: issue.updatedAt.toISOString()
+    };
+    if (issue.description) {
+      result.description = issue.description;
+    }
+    if (issue.state) {
+      const state = await issue.state;
+      if (state == null ? void 0 : state.name) {
+        result.state = state.name;
+      }
+    }
+    return result;
+  } catch (error) {
+    if (error instanceof LinearServiceError) {
+      throw error;
+    }
+    handleLinearError(error, "fetchLinearIssue");
+  }
+}
+async function createLinearIssue(title, body, teamKey, _labels) {
+  try {
+    logger.debug(`Creating Linear issue in team ${teamKey}: ${title}`);
+    const client = createLinearClient();
+    const teams = await client.teams();
+    const team = teams.nodes.find((t) => t.key === teamKey);
+    if (!team) {
+      throw new LinearServiceError("NOT_FOUND", `Linear team ${teamKey} not found`);
+    }
+    const issueInput = {
+      teamId: team.id,
+      title
+    };
+    if (body) {
+      issueInput.description = body;
+    }
+    const payload = await client.createIssue(issueInput);
+    const issue = await payload.issue;
+    if (!issue) {
+      throw new LinearServiceError("CLI_ERROR", "Failed to create Linear issue");
+    }
+    const url = issue.url ?? buildLinearIssueUrl(issue.identifier, title);
+    return {
+      identifier: issue.identifier,
+      url
+    };
+  } catch (error) {
+    if (error instanceof LinearServiceError) {
+      throw error;
+    }
+    handleLinearError(error, "createLinearIssue");
+  }
+}
+async function createLinearChildIssue(title, body, teamKey, parentId, _labels) {
+  try {
+    logger.debug(`Creating Linear child issue in team ${teamKey}: ${title}`);
+    const client = createLinearClient();
+    const teams = await client.teams();
+    const team = teams.nodes.find((t) => t.key === teamKey);
+    if (!team) {
+      throw new LinearServiceError("NOT_FOUND", `Linear team ${teamKey} not found`);
+    }
+    const issueInput = {
+      teamId: team.id,
+      title,
+      parentId
+      // UUID of parent issue
+    };
+    if (body) {
+      issueInput.description = body;
+    }
+    const payload = await client.createIssue(issueInput);
+    const issue = await payload.issue;
+    if (!issue) {
+      throw new LinearServiceError("CLI_ERROR", "Failed to create Linear child issue");
+    }
+    const url = issue.url ?? buildLinearIssueUrl(issue.identifier, title);
+    return {
+      identifier: issue.identifier,
+      url
+    };
+  } catch (error) {
+    if (error instanceof LinearServiceError) {
+      throw error;
+    }
+    handleLinearError(error, "createLinearChildIssue");
+  }
+}
+async function createLinearComment(identifier, body) {
+  try {
+    logger.debug(`Creating comment on Linear issue ${identifier}`);
+    const client = createLinearClient();
+    const issue = await client.issue(identifier);
+    if (!issue) {
+      throw new LinearServiceError("NOT_FOUND", `Linear issue ${identifier} not found`);
+    }
+    const payload = await client.createComment({
+      issueId: issue.id,
+      body
+    });
+    const comment = await payload.comment;
+    if (!comment) {
+      throw new LinearServiceError("CLI_ERROR", "Failed to create Linear comment");
+    }
+    return {
+      id: comment.id,
+      body: comment.body,
+      createdAt: comment.createdAt.toISOString(),
+      updatedAt: comment.updatedAt.toISOString(),
+      url: comment.url
+    };
+  } catch (error) {
+    if (error instanceof LinearServiceError) {
+      throw error;
+    }
+    handleLinearError(error, "createLinearComment");
+  }
+}
+async function updateLinearIssueState(identifier, stateName) {
+  try {
+    logger.debug(`Updating Linear issue ${identifier} state to: ${stateName}`);
+    const client = createLinearClient();
+    const issue = await client.issue(identifier);
+    if (!issue) {
+      throw new LinearServiceError("NOT_FOUND", `Linear issue ${identifier} not found`);
+    }
+    const team = await issue.team;
+    if (!team) {
+      throw new LinearServiceError("CLI_ERROR", "Issue has no team");
+    }
+    const states = await team.states();
+    const state = states.nodes.find((s) => s.name === stateName);
+    if (!state) {
+      throw new LinearServiceError(
+        "NOT_FOUND",
+        `State "${stateName}" not found in team ${team.key}`
+      );
+    }
+    await client.updateIssue(issue.id, {
+      stateId: state.id
+    });
+  } catch (error) {
+    if (error instanceof LinearServiceError) {
+      throw error;
+    }
+    handleLinearError(error, "updateLinearIssueState");
+  }
+}
+async function editLinearIssue(identifier, updates) {
+  try {
+    logger.debug(`Editing Linear issue ${identifier}`, { updates });
+    const client = createLinearClient();
+    const issue = await client.issue(identifier);
+    if (!issue) {
+      throw new LinearServiceError("NOT_FOUND", `Linear issue ${identifier} not found`);
+    }
+    const updatePayload = {};
+    if (updates.title !== void 0) {
+      updatePayload.title = updates.title;
+    }
+    if (updates.description !== void 0) {
+      updatePayload.description = updates.description;
+    }
+    if (Object.keys(updatePayload).length > 0) {
+      await client.updateIssue(issue.id, updatePayload);
+    }
+  } catch (error) {
+    if (error instanceof LinearServiceError) {
+      throw error;
+    }
+    handleLinearError(error, "editLinearIssue");
+  }
+}
+async function getLinearComment(commentId) {
+  try {
+    logger.debug(`Fetching Linear comment: ${commentId}`);
+    const client = createLinearClient();
+    const comment = await client.comment({ id: commentId });
+    if (!comment) {
+      throw new LinearServiceError("NOT_FOUND", `Linear comment ${commentId} not found`);
+    }
+    return {
+      id: comment.id,
+      body: comment.body,
+      createdAt: comment.createdAt.toISOString(),
+      updatedAt: comment.updatedAt.toISOString(),
+      url: comment.url
+    };
+  } catch (error) {
+    if (error instanceof LinearServiceError) {
+      throw error;
+    }
+    handleLinearError(error, "getLinearComment");
+  }
+}
+async function updateLinearComment(commentId, body) {
+  try {
+    logger.debug(`Updating Linear comment: ${commentId}`);
+    const client = createLinearClient();
+    const payload = await client.updateComment(commentId, { body });
+    const comment = await payload.comment;
+    if (!comment) {
+      throw new LinearServiceError("CLI_ERROR", "Failed to update Linear comment");
+    }
+    return {
+      id: comment.id,
+      body: comment.body,
+      createdAt: comment.createdAt.toISOString(),
+      updatedAt: comment.updatedAt.toISOString(),
+      url: comment.url
+    };
+  } catch (error) {
+    if (error instanceof LinearServiceError) {
+      throw error;
+    }
+    handleLinearError(error, "updateLinearComment");
+  }
+}
+async function fetchLinearIssueComments(identifier) {
+  try {
+    logger.debug(`Fetching comments for Linear issue: ${identifier}`);
+    const client = createLinearClient();
+    const issue = await client.issue(identifier);
+    if (!issue) {
+      throw new LinearServiceError("NOT_FOUND", `Linear issue ${identifier} not found`);
+    }
+    const comments = await issue.comments({ first: 100 });
+    return comments.nodes.map((comment) => ({
+      id: comment.id,
+      body: comment.body,
+      createdAt: comment.createdAt.toISOString(),
+      updatedAt: comment.updatedAt.toISOString(),
+      url: comment.url
+    }));
+  } catch (error) {
+    if (error instanceof LinearServiceError) {
+      throw error;
+    }
+    handleLinearError(error, "fetchLinearIssueComments");
+  }
+}
+async function getLinearChildIssues(identifier, options) {
+  try {
+    logger.debug(`Fetching child issues for Linear issue: ${identifier}`);
+    const client = createLinearClient(options == null ? void 0 : options.apiToken);
+    const issue = await client.issue(identifier);
+    if (!issue) {
+      throw new LinearServiceError("NOT_FOUND", `Linear issue ${identifier} not found`);
+    }
+    const children = await issue.children({ first: 100 });
+    const results = await Promise.all(
+      children.nodes.map(async (child) => {
+        const stateObj = await child.state;
+        const state = (stateObj == null ? void 0 : stateObj.name) ?? "unknown";
+        return {
+          id: child.identifier,
+          title: child.title,
+          url: child.url,
+          state
+        };
+      })
+    );
+    return results;
+  } catch (error) {
+    if (error instanceof LinearServiceError) {
+      throw error;
+    }
+    handleLinearError(error, "getLinearChildIssues");
+  }
+}
+async function createLinearIssueRelation(blockingIssueId, blockedIssueId) {
+  try {
+    logger.debug(`Creating Linear issue relation: ${blockingIssueId} blocks ${blockedIssueId}`);
+    const client = createLinearClient();
+    const payload = await client.createIssueRelation({
+      issueId: blockingIssueId,
+      relatedIssueId: blockedIssueId,
+      type: IssueRelationType.Blocks
+    });
+    if (!payload.success) {
+      throw new LinearServiceError("CLI_ERROR", "Failed to create Linear issue relation");
+    }
+  } catch (error) {
+    if (error instanceof LinearServiceError) {
+      throw error;
+    }
+    handleLinearError(error, "createLinearIssueRelation");
+  }
+}
+async function getLinearIssueDependencies(identifier, direction) {
+  try {
+    logger.debug(`Fetching Linear issue dependencies: ${identifier} (direction: ${direction})`);
+    const client = createLinearClient();
+    const issue = await client.issue(identifier);
+    if (!issue) {
+      throw new LinearServiceError("NOT_FOUND", `Linear issue ${identifier} not found`);
+    }
+    const [relations, inverseRelations] = await Promise.all([
+      issue.relations(),
+      issue.inverseRelations()
+    ]);
+    const blocking = [];
+    const blockedBy = [];
+    const buildDependencyResult = async (relatedIssue) => {
+      if (!relatedIssue) return null;
+      const stateObj = await relatedIssue.state;
+      const state = (stateObj == null ? void 0 : stateObj.name) ?? "unknown";
+      return {
+        id: relatedIssue.identifier,
+        title: relatedIssue.title,
+        url: relatedIssue.url,
+        state
+      };
+    };
+    if (direction === "blocking" || direction === "both") {
+      const blockingRelations = relations.nodes.filter(
+        (r) => r.type === IssueRelationType.Blocks
+      );
+      const relatedIssuePromises = blockingRelations.map((r) => r.relatedIssue).filter((p) => p !== void 0);
+      const relatedIssues = await Promise.all(relatedIssuePromises);
+      const blockingResults = await Promise.all(
+        relatedIssues.map((issue2) => buildDependencyResult(issue2))
+      );
+      blocking.push(...blockingResults.filter((r) => r !== null));
+    }
+    if (direction === "blocked_by" || direction === "both") {
+      const blockedByRelations = inverseRelations.nodes.filter(
+        (r) => r.type === IssueRelationType.Blocks
+      );
+      const sourceIssuePromises = blockedByRelations.map((r) => r.issue).filter((p) => p !== void 0);
+      const sourceIssues = await Promise.all(sourceIssuePromises);
+      const blockedByResults = await Promise.all(
+        sourceIssues.map((issue2) => buildDependencyResult(issue2))
+      );
+      blockedBy.push(...blockedByResults.filter((r) => r !== null));
+    }
+    return { blocking, blockedBy };
+  } catch (error) {
+    if (error instanceof LinearServiceError) {
+      throw error;
+    }
+    handleLinearError(error, "getLinearIssueDependencies");
+  }
+}
+async function deleteLinearIssueRelation(relationId) {
+  try {
+    logger.debug(`Deleting Linear issue relation: ${relationId}`);
+    const client = createLinearClient();
+    const payload = await client.deleteIssueRelation(relationId);
+    if (!payload.success) {
+      throw new LinearServiceError("CLI_ERROR", "Failed to delete Linear issue relation");
+    }
+  } catch (error) {
+    if (error instanceof LinearServiceError) {
+      throw error;
+    }
+    handleLinearError(error, "deleteLinearIssueRelation");
+  }
+}
+async function fetchLinearIssueList(teamKey, options) {
+  try {
+    const limit = (options == null ? void 0 : options.limit) ?? 100;
+    logger.debug(`Fetching Linear issue list for team ${teamKey}`, { limit, mine: options == null ? void 0 : options.mine });
+    const client = createLinearClient(options == null ? void 0 : options.apiToken);
+    const teams = await client.teams();
+    const team = teams.nodes.find((t) => t.key === teamKey);
+    if (!team) {
+      throw new LinearServiceError("NOT_FOUND", `Linear team ${teamKey} not found`);
+    }
+    const filter = {
+      state: {
+        type: {
+          nin: ["completed", "canceled"]
+        }
+      }
+    };
+    if (options == null ? void 0 : options.mine) {
+      filter.assignee = { isMe: { eq: true } };
+    }
+    const issues = await team.issues({
+      first: limit,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- PaginationOrderBy is a const enum incompatible with isolatedModules
+      orderBy: "updatedAt",
+      filter
+    });
+    const results = await Promise.all(
+      issues.nodes.map(async (issue) => {
+        const stateObj = await issue.state;
+        const state = (stateObj == null ? void 0 : stateObj.name) ?? "unknown";
+        return {
+          id: issue.identifier,
+          title: issue.title,
+          updatedAt: issue.updatedAt.toISOString(),
+          url: issue.url,
+          state
+        };
+      })
+    );
+    return results;
+  } catch (error) {
+    if (error instanceof LinearServiceError) {
+      throw error;
+    }
+    handleLinearError(error, "fetchLinearIssueList");
+  }
+}
+async function findLinearIssueRelation(blockingIdentifier, blockedIdentifier) {
+  try {
+    logger.debug(`Finding Linear issue relation: ${blockingIdentifier} blocks ${blockedIdentifier}`);
+    const client = createLinearClient();
+    const blockingIssue = await client.issue(blockingIdentifier);
+    if (!blockingIssue) {
+      throw new LinearServiceError("NOT_FOUND", `Linear issue ${blockingIdentifier} not found`);
+    }
+    const blockedIssue = await client.issue(blockedIdentifier);
+    if (!blockedIssue) {
+      throw new LinearServiceError("NOT_FOUND", `Linear issue ${blockedIdentifier} not found`);
+    }
+    const relations = await blockingIssue.relations();
+    const blockingRelations = relations.nodes.filter(
+      (r) => r.type === IssueRelationType.Blocks
+    );
+    const relationsWithIssues = await Promise.all(
+      blockingRelations.map(async (relation) => ({
+        relation,
+        relatedIssue: await relation.relatedIssue
+      }))
+    );
+    const matchingRelation = relationsWithIssues.find(
+      ({ relatedIssue }) => (relatedIssue == null ? void 0 : relatedIssue.id) === blockedIssue.id
+    );
+    return (matchingRelation == null ? void 0 : matchingRelation.relation.id) ?? null;
+  } catch (error) {
+    if (error instanceof LinearServiceError) {
+      throw error;
+    }
+    handleLinearError(error, "findLinearIssueRelation");
+  }
+}
+
+// src/lib/providers/jira/JiraApiClient.ts
+import https from "https";
+
+// src/lib/providers/jira/AdfMarkdownConverter.ts
+import { Parser } from "extended-markdown-adf-parser";
+var parser = new Parser();
+function sanitizeCodeMarks(node) {
+  var _a;
+  if ((_a = node.marks) == null ? void 0 : _a.some((mark) => mark.type === "code")) {
+    node.marks = [{ type: "code" }];
+  }
+  if (node.content && Array.isArray(node.content)) {
+    node.content = node.content.map((child) => sanitizeCodeMarks(child));
+  }
+  return node;
+}
+var BLOCK_LEVEL_TYPES = /* @__PURE__ */ new Set([
+  "paragraph",
+  "bulletList",
+  "orderedList",
+  "codeBlock",
+  "heading",
+  "blockquote",
+  "rule",
+  "mediaGroup",
+  "nestedExpand",
+  "panel",
+  "table",
+  "taskList",
+  "decisionList",
+  "mediaSingle"
+]);
+function wrapTableCellContent(node) {
+  if (node.content && Array.isArray(node.content)) {
+    node.content = node.content.map((child) => wrapTableCellContent(child));
+  }
+  if (node.type !== "tableCell" && node.type !== "tableHeader") {
+    return node;
+  }
+  if (!node.content || node.content.length === 0) {
+    return node;
+  }
+  const allInline = node.content.every((child) => !BLOCK_LEVEL_TYPES.has(child.type));
+  if (allInline) {
+    node.content = [{ type: "paragraph", content: node.content }];
+  } else {
+    const newContent = [];
+    let inlineRun = [];
+    for (const child of node.content) {
+      if (BLOCK_LEVEL_TYPES.has(child.type)) {
+        if (inlineRun.length > 0) {
+          newContent.push({ type: "paragraph", content: inlineRun });
+          inlineRun = [];
+        }
+        newContent.push(child);
+      } else {
+        inlineRun.push(child);
+      }
+    }
+    if (inlineRun.length > 0) {
+      newContent.push({ type: "paragraph", content: inlineRun });
+    }
+    node.content = newContent;
+  }
+  return node;
+}
+var taskIdCounter = 0;
+function getCanonicalPlainText(text) {
+  const miniAdf = parser.markdownToAdf(text);
+  return getPlainText(miniAdf);
+}
+function extractCheckboxBlocks(markdown) {
+  var _a, _b;
+  const lines = markdown.split("\n");
+  const blocks = [];
+  let i = 0;
+  while (i < lines.length) {
+    const bulletLines = [];
+    let blockIndent = null;
+    while (i < lines.length) {
+      const line = lines[i] ?? "";
+      const checkboxMatch = line.match(/^(\s*)[-*+] \[([ xX])\] (.*)$/);
+      if (checkboxMatch) {
+        const indent = ((_a = checkboxMatch[1]) == null ? void 0 : _a.length) ?? 0;
+        if (blockIndent === null) {
+          blockIndent = indent;
+        } else if (indent !== blockIndent) {
+          break;
+        }
+        const state = checkboxMatch[2] === " " ? "TODO" : "DONE";
+        bulletLines.push({ isCheckbox: true, state, rawText: checkboxMatch[3] ?? "" });
+        i++;
+      } else if (line.match(/^\s*[-*+] /)) {
+        const indentMatch = line.match(/^(\s*)/);
+        const indent = ((_b = indentMatch == null ? void 0 : indentMatch[1]) == null ? void 0 : _b.length) ?? 0;
+        if (blockIndent === null) {
+          blockIndent = indent;
+        } else if (indent !== blockIndent) {
+          break;
+        }
+        bulletLines.push({ isCheckbox: false, state: null, rawText: "" });
+        i++;
+      } else if (bulletLines.length > 0 && line.match(/^\s/) && line.trim() !== "") {
+        const lastItem = bulletLines[bulletLines.length - 1];
+        if (lastItem) {
+          lastItem.rawText += "\n" + line.trim();
+        }
+        i++;
+      } else {
+        break;
+      }
+    }
+    if (bulletLines.length > 0) {
+      const allCheckboxes = bulletLines.every((l) => l.isCheckbox);
+      if (allCheckboxes) {
+        blocks.push({
+          states: bulletLines.map((l) => l.state),
+          texts: bulletLines.map((l) => getCanonicalPlainText(l.rawText))
+        });
+      }
+    } else {
+      i++;
+    }
+  }
+  return blocks;
+}
+function getPlainText(node) {
+  if (node.type === "text" && node.text !== void 0) return node.text;
+  if (!node.content) return "";
+  return node.content.map(getPlainText).join("");
+}
+function convertCheckboxesToTaskList(node, blocks) {
+  const cursor = { index: 0 };
+  return convertCheckboxesRecursive(node, blocks, cursor);
+}
+function convertCheckboxesRecursive(node, blocks, cursor) {
+  var _a;
+  if (node.type === "bulletList" && node.content && node.content.length > 0 && cursor.index < blocks.length) {
+    const block = blocks[cursor.index];
+    if (!block) return node;
+    if (node.content.length === block.states.length) {
+      const plaintexts = node.content.map((listItem) => getPlainText(listItem));
+      const matches = plaintexts.every((text, i) => text === block.texts[i]);
+      if (matches) {
+        const allSimple = node.content.every((item) => {
+          var _a2, _b;
+          return ((_a2 = item.content) == null ? void 0 : _a2.length) === 1 && ((_b = item.content[0]) == null ? void 0 : _b.type) === "paragraph";
+        });
+        if (!allSimple) {
+          cursor.index++;
+          return node;
+        }
+        cursor.index++;
+        node.type = "taskList";
+        node.attrs = { localId: `tasklist-${++taskIdCounter}` };
+        for (const [i, listItem] of node.content.entries()) {
+          listItem.type = "taskItem";
+          listItem.attrs = {
+            localId: `task-${++taskIdCounter}`,
+            state: block.states[i]
+          };
+          const firstChild = (_a = listItem.content) == null ? void 0 : _a[0];
+          if ((firstChild == null ? void 0 : firstChild.type) === "paragraph" && firstChild.content) {
+            listItem.content = firstChild.content;
+          }
+        }
+        return node;
+      }
+    }
+  }
+  if (node.content && Array.isArray(node.content)) {
+    node.content = node.content.map((child) => convertCheckboxesRecursive(child, blocks, cursor));
+  }
+  return node;
+}
+function convertDetailsToExpandSyntax(markdown) {
+  if (!markdown) return markdown;
+  let previousText = "";
+  let currentText = markdown;
+  while (previousText !== currentText) {
+    previousText = currentText;
+    currentText = currentText.replace(
+      /<details[^>]*>\s*<summary[^>]*>([\s\S]*?)<\/summary>([\s\S]*?)<\/details>/gi,
+      (_match, summary, content) => {
+        const cleanSummary = summary.trim().replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&").replace(/&quot;/g, '"').replace(/&#39;/g, "'");
+        let cleanContent = content.trim();
+        cleanContent = cleanContent.replace(/\n{3,}/g, "\n\n");
+        if (cleanContent) {
+          return `~~~expand title="${cleanSummary}"
+${cleanContent}
+~~~`;
+        } else {
+          return `~~~expand title="${cleanSummary}"
+~~~`;
+        }
+      }
+    );
+  }
+  return currentText;
+}
+function adfToMarkdown(adf) {
+  if (!adf) return "";
+  if (typeof adf === "string") return adf;
+  return parser.adfToMarkdown(adf);
+}
+function markdownToAdf(markdown) {
+  if (!markdown) {
+    return { type: "doc", version: 1, content: [] };
+  }
+  taskIdCounter = 0;
+  const checkboxBlocks = extractCheckboxBlocks(markdown);
+  const preprocessed = convertDetailsToExpandSyntax(markdown);
+  const adf = parser.markdownToAdf(preprocessed);
+  let result = sanitizeCodeMarks(adf);
+  result = wrapTableCellContent(result);
+  result = convertCheckboxesToTaskList(result, checkboxBlocks);
+  return result;
+}
+
+// src/lib/providers/jira/JiraApiClient.ts
+var JiraApiClient = class {
+  constructor(config) {
+    this.baseUrl = `${config.host.replace(/\/$/, "")}/rest/api/3`;
+    const credentials = Buffer.from(`${config.username}:${config.apiToken}`).toString("base64");
+    this.authHeader = `Basic ${credentials}`;
+  }
+  /**
+   * Make an HTTP request to Jira API
+   */
+  async request(method, endpoint, body) {
+    const url = new URL(`${this.baseUrl}${endpoint}`);
+    getLogger().debug(`Jira API ${method} request`, { url: url.toString() });
+    if (body) {
+      getLogger().debug("Jira API request body", JSON.stringify(body, null, 2));
+    }
+    return new Promise((resolve, reject) => {
+      const options = {
+        hostname: url.hostname,
+        port: url.port || 443,
+        path: url.pathname + url.search,
+        method,
+        headers: {
+          "Authorization": this.authHeader,
+          "Accept": "application/json",
+          "Content-Type": "application/json"
+        }
+      };
+      const req = https.request({ ...options, timeout: 3e4 }, (res) => {
+        const chunks = [];
+        res.on("data", (chunk) => {
+          chunks.push(chunk);
+        });
+        res.on("end", () => {
+          var _a;
+          const data = Buffer.concat(chunks).toString("utf8");
+          if (!res.statusCode || res.statusCode < 200 || res.statusCode >= 300) {
+            let errorDetail = data;
+            try {
+              const parsed = JSON.parse(data);
+              const parts = [];
+              if ((_a = parsed.errorMessages) == null ? void 0 : _a.length) {
+                parts.push(`messages: ${parsed.errorMessages.join(", ")}`);
+              }
+              if (parsed.errors && Object.keys(parsed.errors).length) {
+                parts.push(`field errors: ${JSON.stringify(parsed.errors)}`);
+              }
+              if (parts.length) {
+                errorDetail = parts.join("; ");
+              }
+            } catch {
+            }
+            reject(new Error(`Jira API error (${res.statusCode}): ${errorDetail}`));
+            return;
+          }
+          if (res.statusCode === 204 || !data) {
+            resolve({});
+            return;
+          }
+          try {
+            resolve(JSON.parse(data));
+          } catch (error) {
+            reject(new Error(`Failed to parse Jira API response: ${error}`));
+          }
+        });
+      });
+      req.on("timeout", () => {
+        req.destroy();
+        reject(new Error("Jira API request timed out after 30 seconds"));
+      });
+      req.on("error", (error) => {
+        reject(new Error(`Jira API request failed: ${error.message}`));
+      });
+      if (body) {
+        req.write(JSON.stringify(body));
+      }
+      req.end();
+    });
+  }
+  /**
+   * Make a GET request to Jira API
+   */
+  async get(endpoint) {
+    return this.request("GET", endpoint);
+  }
+  /**
+   * Make a POST request to Jira API
+   */
+  async post(endpoint, body) {
+    return this.request("POST", endpoint, body);
+  }
+  /**
+   * Make a PUT request to Jira API
+   */
+  async put(endpoint, body) {
+    return this.request("PUT", endpoint, body);
+  }
+  /**
+   * Make a DELETE request to Jira API
+   */
+  async delete(endpoint) {
+    await this.request("DELETE", endpoint);
+  }
+  /**
+   * Fetch an issue by key (e.g., "PROJ-123")
+   */
+  async getIssue(issueKey) {
+    return this.get(`/issue/${issueKey}`);
+  }
+  /**
+   * Add a comment to an issue
+   * Accepts Markdown content which is converted to ADF for Jira
+   */
+  async addComment(issueKey, body) {
+    const adfBody = markdownToAdf(body);
+    getLogger().debug("Adding comment to Jira issue", { issueKey, bodyLength: body.length });
+    return this.post(`/issue/${issueKey}/comment`, {
+      body: adfBody
+    });
+  }
+  /**
+   * Get all comments for an issue
+   */
+  async getComments(issueKey) {
+    const response = await this.get(`/issue/${issueKey}/comment?maxResults=5000`);
+    if (response.total > response.comments.length) {
+      getLogger().warn(`Comments truncated for issue ${issueKey}: returned ${response.comments.length} of ${response.total} total comments`);
+    }
+    return response.comments;
+  }
+  /**
+   * Update a comment on an issue
+   * Accepts Markdown content which is converted to ADF for Jira
+   */
+  async updateComment(issueKey, commentId, body) {
+    return this.put(`/issue/${issueKey}/comment/${commentId}`, {
+      body: markdownToAdf(body)
+    });
+  }
+  /**
+   * Get available transitions for an issue
+   */
+  async getTransitions(issueKey) {
+    const response = await this.get(`/issue/${issueKey}/transitions`);
+    return response.transitions;
+  }
+  /**
+   * Transition an issue to a new state
+   */
+  async transitionIssue(issueKey, transitionId) {
+    await this.post(`/issue/${issueKey}/transitions`, {
+      transition: {
+        id: transitionId
+      }
+    });
+  }
+  /**
+   * Create a new issue
+   * Accepts Markdown description which is converted to ADF for Jira
+   */
+  async createIssue(projectKey, summary, description, issueType = "Task") {
+    return this.post("/issue", {
+      fields: {
+        project: {
+          key: projectKey
+        },
+        summary,
+        description: markdownToAdf(description),
+        issuetype: {
+          name: issueType
+        }
+      }
+    });
+  }
+  /**
+   * Update an issue's fields (summary, description)
+   * @param issueKey - Jira issue key (e.g., "PROJ-123")
+   * @param fields - Fields to update
+   */
+  async updateIssue(issueKey, fields) {
+    const updateFields = {};
+    if (fields.summary !== void 0) {
+      updateFields.summary = fields.summary;
+    }
+    if (fields.description !== void 0) {
+      updateFields.description = markdownToAdf(fields.description);
+    }
+    await this.put(`/issue/${issueKey}`, { fields: updateFields });
+  }
+  /**
+   * Create an issue with a parent (subtask or child issue)
+   * Accepts Markdown description which is converted to ADF for Jira
+   */
+  async createIssueWithParent(projectKey, summary, description, parentKey, issueType = "Subtask") {
+    return this.post("/issue", {
+      fields: {
+        project: {
+          key: projectKey
+        },
+        summary,
+        description: markdownToAdf(description),
+        issuetype: {
+          name: issueType
+        },
+        parent: {
+          key: parentKey
+        }
+      }
+    });
+  }
+  /**
+   * Create an issue link (dependency/relationship between issues)
+   * @param inwardKey - The issue key for the inward side (e.g., the blocked issue)
+   * @param outwardKey - The issue key for the outward side (e.g., the blocking issue)
+   * @param linkType - The link type name (e.g., "Blocks")
+   */
+  async createIssueLink(inwardKey, outwardKey, linkType) {
+    await this.post("/issueLink", {
+      type: {
+        name: linkType
+      },
+      inwardIssue: {
+        key: inwardKey
+      },
+      outwardIssue: {
+        key: outwardKey
+      }
+    });
+  }
+  /**
+   * Delete an issue link by ID
+   */
+  async deleteIssueLink(linkId) {
+    await this.delete(`/issueLink/${linkId}`);
+  }
+  /**
+   * Search issues using JQL
+   * Automatically paginates through all results up to MAX_SEARCH_RESULTS.
+   */
+  async searchIssues(jql) {
+    const MAX_SEARCH_RESULTS = 5e3;
+    const allIssues = [];
+    let nextPageToken;
+    const maxResults = 100;
+    while (allIssues.length < MAX_SEARCH_RESULTS) {
+      const body = {
+        jql,
+        maxResults,
+        fields: [
+          "summary",
+          "description",
+          "status",
+          "issuetype",
+          "project",
+          "assignee",
+          "reporter",
+          "labels",
+          "created",
+          "updated",
+          "issuelinks",
+          "parent"
+        ]
+      };
+      if (nextPageToken) {
+        body.nextPageToken = nextPageToken;
+      }
+      const response = await this.post(
+        "/search/jql",
+        body
+      );
+      allIssues.push(...response.issues);
+      if (!response.nextPageToken || response.issues.length === 0) {
+        break;
+      }
+      nextPageToken = response.nextPageToken;
+    }
+    if (allIssues.length >= MAX_SEARCH_RESULTS) {
+      getLogger().warn(`Search results truncated at ${MAX_SEARCH_RESULTS} issues. The query matched more results than the safety cap allows.`, { jql, returnedCount: allIssues.length });
+    }
+    return allIssues;
+  }
+  /**
+   * Test connection to Jira API
+   */
+  async testConnection() {
+    try {
+      await this.get("/myself");
+      return true;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (message.includes("Jira API error (401)") || message.includes("Jira API error (403)")) {
+        getLogger().error("Jira connection test failed: authentication error", { error });
+        return false;
+      }
+      throw error;
+    }
+  }
+};
+
+// src/lib/providers/jira/JiraIssueTracker.ts
+var JiraIssueTracker = class {
+  constructor(config, options) {
+    this.providerName = "jira";
+    this.supportsPullRequests = false;
+    this.config = config;
+    this.client = new JiraApiClient({
+      host: config.host,
+      username: config.username,
+      apiToken: config.apiToken
+    });
+    this.prompter = (options == null ? void 0 : options.prompter) ?? promptConfirmation;
+  }
+  /**
+   * Normalize identifier to canonical uppercase form
+   * Jira issue keys are case-sensitive in the API (must be uppercase)
+   */
+  normalizeIdentifier(identifier) {
+    return String(identifier).toUpperCase();
+  }
+  /**
+   * Detect input type from user input
+   * Jira issues follow pattern: PROJECTKEY-123 (case-insensitive)
+   */
+  async detectInputType(input) {
+    const jiraPattern = /^([A-Z][A-Z0-9]+)-(\d+)$/i;
+    const match = input.match(jiraPattern);
+    if (!match) {
+      return { type: "unknown", identifier: null, rawInput: input };
+    }
+    const issueKey = this.normalizeIdentifier(input);
+    getLogger().debug("Checking if input is a Jira issue", { issueKey });
+    try {
+      await this.client.getIssue(issueKey);
+      return { type: "issue", identifier: issueKey, rawInput: input };
+    } catch (error) {
+      if (error instanceof Error && (/404/.test(error.message) || /not found/i.test(error.message))) {
+        getLogger().debug("Issue not found", { issueKey, error });
+        return { type: "unknown", identifier: null, rawInput: input };
+      }
+      throw error;
+    }
+  }
+  /**
+   * Fetch issue details
+   */
+  async fetchIssue(identifier) {
+    const issueKey = this.normalizeIdentifier(identifier);
+    getLogger().debug("Fetching Jira issue", { issueKey });
+    const jiraIssue = await this.client.getIssue(issueKey);
+    return this.mapJiraIssueToIssue(jiraIssue);
+  }
+  /**
+   * Check if issue exists (silent validation)
+   */
+  async isValidIssue(identifier) {
+    try {
+      return await this.fetchIssue(identifier);
+    } catch (error) {
+      if (error instanceof Error && (/404/.test(error.message) || /not found/i.test(error.message))) {
+        getLogger().debug("Issue validation failed: not found", { identifier, error });
+        return false;
+      }
+      throw error;
+    }
+  }
+  /**
+   * Validate issue state
+   * Note: Jira doesn't have a simple "closed" state - depends on workflow
+   */
+  async validateIssueState(issue) {
+    getLogger().debug("Jira issue state", { issueKey: issue.number, state: issue.state });
+    if (issue.state === "closed") {
+      const shouldContinue = await this.prompter(
+        `Issue ${issue.number} is in a completed state. Continue anyway?`
+      );
+      if (!shouldContinue) {
+        throw new Error("User cancelled due to completed issue");
+      }
+    }
+  }
+  /**
+   * Create a new issue
+   */
+  async createIssue(title, body, _repository, _labels) {
+    getLogger().debug("Creating Jira issue", { title, projectKey: this.config.projectKey });
+    const jiraIssue = await this.client.createIssue(
+      this.config.projectKey,
+      title,
+      body,
+      this.config.defaultIssueType
+    );
+    return {
+      number: jiraIssue.key,
+      url: `${this.config.host}/browse/${jiraIssue.key}`
+    };
+  }
+  /**
+   * Get issue URL
+   */
+  async getIssueUrl(identifier) {
+    const issueKey = this.normalizeIdentifier(identifier);
+    return `${this.config.host}/browse/${issueKey}`;
+  }
+  /**
+   * Move issue to "In Progress" state
+   * Uses configured transition mapping or default transition name
+   */
+  async moveIssueToInProgress(identifier) {
+    var _a;
+    const issueKey = this.normalizeIdentifier(identifier);
+    getLogger().debug("Moving Jira issue to In Progress", { issueKey });
+    const transitions = await this.client.getTransitions(issueKey);
+    const transitionName = ((_a = this.config.transitionMappings) == null ? void 0 : _a["In Progress"]) ?? this.findTransitionByName(transitions, ["In Progress", "Start Progress", "Start"]);
+    if (!transitionName) {
+      throw new Error(
+        `Could not find "In Progress" transition for ${issueKey}. Available transitions: ${transitions.map((t) => t.name).join(", ")}. Configure custom mapping in settings.json: issueManagement.jira.transitionMappings`
+      );
+    }
+    const transition = transitions.find((t) => t.name === transitionName);
+    if (!transition) {
+      throw new Error(`Transition "${transitionName}" not found`);
+    }
+    await this.client.transitionIssue(issueKey, transition.id);
+    getLogger().info("Issue transitioned successfully", { issueKey, transition: transitionName });
+  }
+  /**
+   * Move issue to "Ready for Review" state
+   * Uses configured transition mapping or default transition name
+   */
+  async moveIssueToReadyForReview(identifier) {
+    var _a;
+    const issueKey = this.normalizeIdentifier(identifier);
+    getLogger().debug("Moving Jira issue to Ready for Review", { issueKey });
+    const transitions = await this.client.getTransitions(issueKey);
+    const transitionName = ((_a = this.config.transitionMappings) == null ? void 0 : _a["Ready for Review"]) ?? this.findTransitionByName(transitions, ["Ready for Review", "In Review", "Code Review", "Review"]);
+    if (!transitionName) {
+      throw new Error(
+        `Could not find "Ready for Review" transition for ${issueKey}. Available transitions: ${transitions.map((t) => t.name).join(", ")}. Configure custom mapping in settings.json: issueManagement.jira.transitionMappings`
+      );
+    }
+    const transition = transitions.find((t) => t.name === transitionName);
+    if (!transition) {
+      throw new Error(`Transition "${transitionName}" not found`);
+    }
+    await this.client.transitionIssue(issueKey, transition.id);
+    getLogger().info("Issue transitioned to Ready for Review", { issueKey, transition: transitionName });
+  }
+  /**
+   * Close an issue by transitioning to "Done" state
+   * Uses configured transition mapping or default transition names
+   */
+  async closeIssue(identifier) {
+    var _a;
+    const issueKey = this.normalizeIdentifier(identifier);
+    getLogger().debug("Closing Jira issue", { issueKey });
+    const transitions = await this.client.getTransitions(issueKey);
+    const transitionName = ((_a = this.config.transitionMappings) == null ? void 0 : _a["Done"]) ?? this.findTransitionByName(transitions, ["Done", "Close", "Closed", "Resolve", "Resolved"]);
+    if (!transitionName) {
+      throw new Error(
+        `Could not find "Done" transition for ${issueKey}. Available transitions: ${transitions.map((t) => t.name).join(", ")}. Configure custom mapping in settings.json: issueManagement.jira.transitionMappings`
+      );
+    }
+    const transition = transitions.find((t) => t.name === transitionName);
+    if (!transition) {
+      throw new Error(`Transition "${transitionName}" not found`);
+    }
+    await this.client.transitionIssue(issueKey, transition.id);
+    getLogger().info("Issue closed successfully", { issueKey, transition: transitionName });
+  }
+  /**
+   * Reopen an issue by transitioning back to an open state
+   * Uses configured transition mapping or default transition names
+   */
+  async reopenIssue(identifier) {
+    var _a;
+    const issueKey = this.normalizeIdentifier(identifier);
+    getLogger().debug("Reopening Jira issue", { issueKey });
+    const transitions = await this.client.getTransitions(issueKey);
+    const transitionName = ((_a = this.config.transitionMappings) == null ? void 0 : _a["Reopen"]) ?? this.findTransitionByName(transitions, ["Reopen", "To Do", "Open", "Backlog"]);
+    if (!transitionName) {
+      throw new Error(
+        `Could not find "Reopen" transition for ${issueKey}. Available transitions: ${transitions.map((t) => t.name).join(", ")}. Configure custom mapping in settings.json: issueManagement.jira.transitionMappings`
+      );
+    }
+    const transition = transitions.find((t) => t.name === transitionName);
+    if (!transition) {
+      throw new Error(`Transition "${transitionName}" not found`);
+    }
+    await this.client.transitionIssue(issueKey, transition.id);
+    getLogger().info("Issue reopened successfully", { issueKey, transition: transitionName });
+  }
+  /**
+   * Extract context from issue for AI prompts
+   */
+  extractContext(entity) {
+    return `Issue: ${entity.number}
+Title: ${entity.title}
+Status: ${entity.state}
+URL: ${entity.url}
+
+Description:
+${entity.body}
+
+${entity.labels.length > 0 ? `Labels: ${entity.labels.join(", ")}` : ""}
+${entity.assignees.length > 0 ? `Assignees: ${entity.assignees.join(", ")}` : ""}`;
+  }
+  /**
+   * Fetch child issues of a Jira parent issue using JQL
+   * @param parentIdentifier - Jira issue key (e.g., "PROJ-123")
+   * @param _repo - Repository (unused for Jira)
+   * @returns Array of child issues
+   */
+  async getChildIssues(parentIdentifier, _repo) {
+    const parentKey = this.normalizeIdentifier(parentIdentifier);
+    const jiraKeyPattern = /^[A-Z][A-Z0-9]+-\d+$/;
+    if (!jiraKeyPattern.test(parentKey)) {
+      getLogger().warn(`Invalid Jira issue key format: ${parentKey}`);
+      return [];
+    }
+    const issues = await this.client.searchIssues(`parent = ${parentKey}`);
+    return issues.map((issue) => ({
+      id: issue.key,
+      title: issue.fields.summary,
+      url: `${this.config.host}/browse/${issue.key}`,
+      state: issue.fields.status.name.toLowerCase()
+    }));
+  }
+  /**
+   * Get issue details (alias for fetchIssue for MCP compatibility)
+   */
+  async getIssue(identifier) {
+    return this.fetchIssue(identifier);
+  }
+  /**
+   * Get all comments for an issue
+   */
+  async getComments(identifier) {
+    const issueKey = this.normalizeIdentifier(identifier);
+    getLogger().debug("Fetching Jira comments", { issueKey });
+    const comments = await this.client.getComments(issueKey);
+    return comments.map((comment) => ({
+      id: comment.id,
+      body: adfToMarkdown(comment.body),
+      author: comment.author,
+      createdAt: comment.created,
+      updatedAt: comment.updated
+    }));
+  }
+  /**
+   * Add a comment to an issue
+   */
+  async addComment(identifier, body) {
+    const issueKey = this.normalizeIdentifier(identifier);
+    getLogger().debug("Adding Jira comment", { issueKey });
+    const comment = await this.client.addComment(issueKey, body);
+    return { id: comment.id };
+  }
+  /**
+   * Update an existing comment
+   */
+  async updateComment(identifier, commentId, body) {
+    const issueKey = this.normalizeIdentifier(identifier);
+    getLogger().debug("Updating Jira comment", { issueKey, commentId });
+    await this.client.updateComment(issueKey, commentId, body);
+  }
+  /**
+   * Get the underlying API client (for direct API access by MCP provider)
+   */
+  getApiClient() {
+    return this.client;
+  }
+  /**
+   * Get configuration (for MCP provider)
+   */
+  getConfig() {
+    return this.config;
+  }
+  /**
+   * Map Jira API issue to generic Issue type
+   */
+  mapJiraIssueToIssue(jiraIssue) {
+    const description = adfToMarkdown(jiraIssue.fields.description);
+    return {
+      id: jiraIssue.id,
+      key: jiraIssue.key,
+      number: jiraIssue.key,
+      title: jiraIssue.fields.summary,
+      body: description,
+      state: this.mapJiraStatusToState(jiraIssue.fields.status.name),
+      labels: jiraIssue.fields.labels,
+      assignees: jiraIssue.fields.assignee ? [jiraIssue.fields.assignee.displayName] : [],
+      assignee: jiraIssue.fields.assignee,
+      author: jiraIssue.fields.reporter,
+      url: `${this.config.host}/browse/${jiraIssue.key}`,
+      issueType: jiraIssue.fields.issuetype.name,
+      status: jiraIssue.fields.status.name
+    };
+  }
+  mapJiraStatusToState(statusName) {
+    const normalized = statusName.toLowerCase();
+    const closedStatuses = ["done", "closed", "resolved", "cancelled", "canceled"];
+    return closedStatuses.includes(normalized) ? "closed" : "open";
+  }
+  /**
+   * Find a transition by name, trying multiple possible names
+   */
+  findTransitionByName(transitions, names) {
+    for (const name of names) {
+      const transition = transitions.find(
+        (t) => t.name.toLowerCase() === name.toLowerCase()
+      );
+      if (transition) {
+        return transition.name;
+      }
+    }
+    return null;
+  }
+};
+
+export {
+  LinearServiceError,
+  fetchLinearIssue,
+  createLinearIssue,
+  createLinearChildIssue,
+  createLinearComment,
+  updateLinearIssueState,
+  editLinearIssue,
+  getLinearComment,
+  updateLinearComment,
+  fetchLinearIssueComments,
+  getLinearChildIssues,
+  createLinearIssueRelation,
+  getLinearIssueDependencies,
+  deleteLinearIssueRelation,
+  fetchLinearIssueList,
+  findLinearIssueRelation,
+  JiraApiClient,
+  JiraIssueTracker
+};
+//# sourceMappingURL=chunk-HEXKPKCK.js.map