@iloom/cli 0.9.2 → 0.10.0

package/dist/{chunk-ULSWCPQG.js → chunk-JO2LZ6EQ.js}

@@ -1,32 +1,44 @@
 #!/usr/bin/env node
 import {
+  escapeJql
+} from "./chunk-4232AHNQ.js";
+import {
+  SettingsManager
+} from "./chunk-YYAKPQBT.js";
+import {
+  JiraIssueTracker,
   createLinearChildIssue,
   createLinearComment,
   createLinearIssue,
   createLinearIssueRelation,
   deleteLinearIssueRelation,
+  editLinearIssue,
   fetchLinearIssue,
   fetchLinearIssueComments,
   findLinearIssueRelation,
   getLinearChildIssues,
   getLinearComment,
   getLinearIssueDependencies,
-  updateLinearComment
-} from "./chunk-FJDRTVJX.js";
+  updateLinearComment,
+  updateLinearIssueState
+} from "./chunk-HEXKPKCK.js";
 import {
   addSubIssue,
+  closeGhIssue,
   createIssue,
   createIssueComment,
   createIssueDependency,
   createPRComment,
+  editGhIssue,
   executeGhCommand,
   getIssueDatabaseId,
   getIssueDependencies,
   getIssueNodeId,
   getSubIssues,
   removeIssueDependency,
+  reopenGhIssue,
   updateIssueComment
-} from "./chunk-4CO6KG5S.js";
+} from "./chunk-VG45TUYK.js";
 import {
   logger
 } from "./chunk-VT4PDUYT.js";
@@ -429,6 +441,55 @@ var GitHubIssueManagementProvider = class {
     }
     return result;
   }
+  /**
+   * Fetch PR review comments (inline code comments on specific files/lines)
+   * Uses gh api with --paginate to handle PRs with many review comments
+   * Optionally filters by review ID
+   */
+  async getReviewComments(input) {
+    const { number, reviewId, repo } = input;
+    const prNumber = parseInt(number, 10);
+    if (isNaN(prNumber)) {
+      throw new Error(`Invalid GitHub PR number: ${number}. GitHub PR IDs must be numeric.`);
+    }
+    let numericReviewId;
+    if (reviewId) {
+      numericReviewId = parseInt(reviewId, 10);
+      if (isNaN(numericReviewId)) {
+        throw new Error(`Invalid review ID: ${reviewId}. Review IDs must be numeric.`);
+      }
+    }
+    const apiPath = repo ? `repos/${repo}/pulls/${prNumber}/comments` : `repos/:owner/:repo/pulls/${prNumber}/comments`;
+    const args = [
+      "api",
+      apiPath,
+      "--paginate",
+      "--jq",
+      "[.[] | {id: .id, body: .body, path: .path, line: .line, side: .side, user: .user, created_at: .created_at, updated_at: .updated_at, in_reply_to_id: .in_reply_to_id, pull_request_review_id: .pull_request_review_id}]"
+    ];
+    const raw = await executeGhCommand(args);
+    let comments = raw;
+    if (numericReviewId !== void 0) {
+      comments = comments.filter((c) => c.pull_request_review_id === numericReviewId);
+    }
+    const results = [];
+    for (const comment of comments) {
+      const processedBody = await processMarkdownImages(comment.body, "github");
+      results.push({
+        id: String(comment.id),
+        body: processedBody,
+        path: comment.path,
+        line: comment.line,
+        side: comment.side,
+        author: normalizeAuthor(comment.user),
+        createdAt: comment.created_at,
+        updatedAt: comment.updated_at ?? null,
+        inReplyToId: comment.in_reply_to_id ? String(comment.in_reply_to_id) : null,
+        pullRequestReviewId: comment.pull_request_review_id
+      });
+    }
+    return results;
+  }
   /**
    * Fetch a specific comment by ID using gh API
    * Normalizes author to FlexibleAuthor format
@@ -588,6 +649,55 @@ var GitHubIssueManagementProvider = class {
     }
     return await getSubIssues(issueNumber, repo);
   }
+  /**
+   * Close an issue
+   */
+  async closeIssue(input) {
+    const { number, repo } = input;
+    const issueNumber = parseInt(number, 10);
+    if (isNaN(issueNumber)) {
+      throw new Error(`Invalid GitHub issue number: ${number}. GitHub issue IDs must be numeric.`);
+    }
+    await closeGhIssue(issueNumber, repo);
+  }
+  /**
+   * Reopen a closed issue
+   */
+  async reopenIssue(input) {
+    const { number, repo } = input;
+    const issueNumber = parseInt(number, 10);
+    if (isNaN(issueNumber)) {
+      throw new Error(`Invalid GitHub issue number: ${number}. GitHub issue IDs must be numeric.`);
+    }
+    await reopenGhIssue(issueNumber, repo);
+  }
+  /**
+   * Edit an issue's properties
+   * State changes are delegated to closeIssue/reopenIssue
+   */
+  async editIssue(input) {
+    const { number, title, body, state, labels, repo } = input;
+    const issueNumber = parseInt(number, 10);
+    if (isNaN(issueNumber)) {
+      throw new Error(`Invalid GitHub issue number: ${number}. GitHub issue IDs must be numeric.`);
+    }
+    if (state === "closed") {
+      await this.closeIssue({ number, repo });
+    } else if (state === "open") {
+      await this.reopenIssue({ number, repo });
+    }
+    if (title !== void 0 || body !== void 0 || labels !== void 0) {
+      await editGhIssue(
+        issueNumber,
+        {
+          ...title !== void 0 && { title },
+          ...body !== void 0 && { body },
+          ...labels !== void 0 && { labels }
+        },
+        repo
+      );
+    }
+  }
 };
 
 // src/utils/linear-markup-converter.ts
@@ -940,19 +1050,380 @@ var LinearIssueManagementProvider = class {
     const { number } = input;
     return await getLinearChildIssues(number);
   }
+  /**
+   * Close an issue by transitioning to "Done" state
+   */
+  async closeIssue(input) {
+    const { number } = input;
+    await updateLinearIssueState(number, "Done");
+  }
+  /**
+   * Reopen a closed issue by transitioning to "Todo" state
+   */
+  async reopenIssue(input) {
+    const { number } = input;
+    await updateLinearIssueState(number, "Todo");
+  }
+  /**
+   * Edit an issue's properties
+   * State changes are delegated to closeIssue/reopenIssue
+   */
+  async editIssue(input) {
+    const { number, title, body, state } = input;
+    if (state === "closed") {
+      await this.closeIssue({ number });
+    } else if (state === "open") {
+      await this.reopenIssue({ number });
+    }
+    if (title !== void 0 || body !== void 0) {
+      await editLinearIssue(number, {
+        ...title !== void 0 && { title },
+        ...body !== void 0 && { description: body }
+      });
+    }
+  }
+};
+
+// src/mcp/JiraIssueManagementProvider.ts
+function normalizeAuthor2(author) {
+  if (!author) return null;
+  return {
+    id: author.accountId ?? author.emailAddress ?? "unknown",
+    displayName: author.displayName ?? author.emailAddress ?? "Unknown",
+    ...author.emailAddress && { email: author.emailAddress },
+    ...author.accountId && { accountId: author.accountId }
+  };
+}
+var getJiraTrackerConfig = (settings) => {
+  var _a;
+  const jiraSettings = (_a = settings.issueManagement) == null ? void 0 : _a.jira;
+  if ((jiraSettings == null ? void 0 : jiraSettings.host) && (jiraSettings == null ? void 0 : jiraSettings.username) && (jiraSettings == null ? void 0 : jiraSettings.apiToken) && (jiraSettings == null ? void 0 : jiraSettings.projectKey)) {
+    const config = {
+      host: jiraSettings.host,
+      username: jiraSettings.username,
+      apiToken: jiraSettings.apiToken,
+      projectKey: jiraSettings.projectKey
+    };
+    if (jiraSettings.transitionMappings) {
+      config.transitionMappings = jiraSettings.transitionMappings;
+    }
+    if (jiraSettings.defaultIssueType) {
+      config.defaultIssueType = jiraSettings.defaultIssueType;
+    }
+    if (jiraSettings.defaultSubtaskType) {
+      config.defaultSubtaskType = jiraSettings.defaultSubtaskType;
+    }
+    return config;
+  }
+  if (process.env.JIRA_HOST && process.env.JIRA_USERNAME && process.env.JIRA_API_TOKEN && process.env.JIRA_PROJECT_KEY) {
+    const config = {
+      host: process.env.JIRA_HOST,
+      username: process.env.JIRA_USERNAME,
+      apiToken: process.env.JIRA_API_TOKEN,
+      projectKey: process.env.JIRA_PROJECT_KEY
+    };
+    if (process.env.JIRA_TRANSITION_MAPPINGS) {
+      try {
+        config.transitionMappings = JSON.parse(process.env.JIRA_TRANSITION_MAPPINGS);
+      } catch {
+        throw new Error("Invalid JSON in JIRA_TRANSITION_MAPPINGS environment variable");
+      }
+    }
+    if (process.env.JIRA_DEFAULT_ISSUE_TYPE) {
+      config.defaultIssueType = process.env.JIRA_DEFAULT_ISSUE_TYPE;
+    }
+    if (process.env.JIRA_DEFAULT_SUBTASK_TYPE) {
+      config.defaultSubtaskType = process.env.JIRA_DEFAULT_SUBTASK_TYPE;
+    }
+    return config;
+  }
+  throw new Error(
+    "Missing required Jira settings: issueManagement.jira.{host, username, apiToken, projectKey} or corresponding environment variables"
+  );
+};
+var JiraIssueManagementProvider = class _JiraIssueManagementProvider {
+  constructor(settings) {
+    this.providerName = "jira";
+    this.issuePrefix = "";
+    const config = getJiraTrackerConfig(settings);
+    this.tracker = new JiraIssueTracker(config);
+    this.projectKey = config.projectKey;
+  }
+  /**
+   * Static factory for convenience when settings aren't pre-loaded
+   */
+  static async create() {
+    const settingsManager = new SettingsManager();
+    const settings = await settingsManager.loadSettings();
+    return new _JiraIssueManagementProvider(settings);
+  }
+  /**
+   * Fetch issue details using JiraIssueTracker
+   */
+  async getIssue(input) {
+    const { number, includeComments = true } = input;
+    const issue = await this.tracker.getIssue(number);
+    const issueExt = issue;
+    const result = {
+      id: issueExt.id ?? String(issue.number),
+      title: issue.title,
+      body: issue.body,
+      state: issue.state,
+      url: issue.url,
+      provider: "jira",
+      author: normalizeAuthor2(issueExt.author),
+      number: issue.number,
+      key: issueExt.key,
+      // Preserve Jira-specific fields
+      ...issueExt.issueType && { issueType: issueExt.issueType },
+      ...issueExt.priority && { priority: issueExt.priority },
+      ...issueExt.status && { status: issueExt.status }
+    };
+    if (issue.labels && issue.labels.length > 0) {
+      result.labels = issue.labels.map((label) => ({ name: label }));
+    }
+    if (issue.assignees && issue.assignees.length > 0) {
+      result.assignees = issue.assignees.map((name) => ({
+        id: name,
+        displayName: name
+      }));
+    }
+    if (includeComments) {
+      const comments = await this.tracker.getComments(number);
+      result.comments = comments.map((comment) => ({
+        id: comment.id,
+        body: comment.body,
+        author: normalizeAuthor2(comment.author),
+        createdAt: comment.createdAt,
+        updatedAt: comment.updatedAt
+      }));
+    }
+    return result;
+  }
+  /**
+   * Fetch a specific comment by ID
+   */
+  async getComment(input) {
+    const { commentId, number } = input;
+    const comments = await this.tracker.getComments(number);
+    const comment = comments.find((c) => c.id === commentId);
+    if (!comment) {
+      throw new Error(`Comment ${commentId} not found on issue ${number}`);
+    }
+    return {
+      id: comment.id,
+      body: comment.body,
+      author: normalizeAuthor2(comment.author),
+      created_at: comment.createdAt,
+      updated_at: comment.updatedAt
+    };
+  }
+  /**
+   * Create a new comment on an issue
+   */
+  async createComment(input) {
+    const { number, body } = input;
+    const normalizedKey = this.tracker.normalizeIdentifier(number);
+    const comment = await this.tracker.addComment(normalizedKey, body);
+    return {
+      id: comment.id,
+      url: `${this.tracker.getConfig().host}/browse/${normalizedKey}?focusedCommentId=${comment.id}`,
+      created_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /**
+   * Update an existing comment
+   */
+  async updateComment(input) {
+    const { commentId, number, body } = input;
+    const normalizedKey = this.tracker.normalizeIdentifier(number);
+    await this.tracker.updateComment(normalizedKey, commentId, body);
+    return {
+      id: commentId,
+      url: `${this.tracker.getConfig().host}/browse/${normalizedKey}?focusedCommentId=${commentId}`,
+      updated_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /**
+   * Create a new issue
+   */
+  async createIssue(input) {
+    const { title, body } = input;
+    const issue = await this.tracker.createIssue(title, body);
+    const result = {
+      id: String(issue.number),
+      url: issue.url
+    };
+    if (typeof issue.number === "number") {
+      result.number = issue.number;
+    }
+    return result;
+  }
+  /**
+   * Fetch pull request details
+   * Jira does not have pull requests - throw like Linear does
+   */
+  async getPR(_input) {
+    throw new Error(
+      "Jira does not support pull requests. PRs exist only on GitHub. Use the GitHub provider for PR operations."
+    );
+  }
+  /**
+   * Create a child issue linked to a parent issue
+   * Uses Jira's parent field to create a subtask
+   */
+  async createChildIssue(input) {
+    const { parentId, title, body } = input;
+    const parentKey = this.tracker.normalizeIdentifier(parentId);
+    const jiraIssue = await this.tracker.getApiClient().createIssueWithParent(
+      this.projectKey,
+      title,
+      body,
+      parentKey,
+      this.tracker.getConfig().defaultSubtaskType
+    );
+    return {
+      id: jiraIssue.key,
+      url: `${this.tracker.getConfig().host}/browse/${jiraIssue.key}`
+    };
+  }
+  /**
+   * Create a blocking dependency between two issues
+   * Uses Jira issue links with "Blocks" link type
+   */
+  async createDependency(input) {
+    const blockingKey = this.tracker.normalizeIdentifier(input.blockingIssue);
+    const blockedKey = this.tracker.normalizeIdentifier(input.blockedIssue);
+    await this.tracker.getApiClient().createIssueLink(blockingKey, blockedKey, "Blocks");
+  }
+  /**
+   * Get dependencies for an issue
+   * Parses issue links of type "Blocks"
+   */
+  async getDependencies(input) {
+    const issueKey = this.tracker.normalizeIdentifier(input.number);
+    const host = this.tracker.getConfig().host;
+    const issue = await this.tracker.getApiClient().getIssue(issueKey);
+    const links = issue.fields.issuelinks ?? [];
+    const blocking = [];
+    const blockedBy = [];
+    for (const link of links) {
+      if (link.type.name !== "Blocks") continue;
+      if (link.inwardIssue) {
+        blockedBy.push({
+          id: link.inwardIssue.key,
+          title: link.inwardIssue.fields.summary,
+          url: `${host}/browse/${link.inwardIssue.key}`,
+          state: link.inwardIssue.fields.status.name.toLowerCase()
+        });
+      }
+      if (link.outwardIssue) {
+        blocking.push({
+          id: link.outwardIssue.key,
+          title: link.outwardIssue.fields.summary,
+          url: `${host}/browse/${link.outwardIssue.key}`,
+          state: link.outwardIssue.fields.status.name.toLowerCase()
+        });
+      }
+    }
+    if (input.direction === "blocking") {
+      return { blocking, blockedBy: [] };
+    }
+    if (input.direction === "blocked_by") {
+      return { blocking: [], blockedBy };
+    }
+    return { blocking, blockedBy };
+  }
+  /**
+   * Remove a blocking dependency between two issues
+   * Finds the matching "Blocks" link and deletes it
+   */
+  async removeDependency(input) {
+    const blockingKey = this.tracker.normalizeIdentifier(input.blockingIssue);
+    const blockedKey = this.tracker.normalizeIdentifier(input.blockedIssue);
+    const issue = await this.tracker.getApiClient().getIssue(blockedKey);
+    const links = issue.fields.issuelinks ?? [];
+    const matchingLink = links.find(
+      (link) => {
+        var _a;
+        return link.type.name === "Blocks" && ((_a = link.inwardIssue) == null ? void 0 : _a.key) === blockingKey;
+      }
+    );
+    if (!matchingLink) {
+      throw new Error(
+        `No "Blocks" dependency found from ${blockingKey} to ${blockedKey}`
+      );
+    }
+    await this.tracker.getApiClient().deleteIssueLink(matchingLink.id);
+  }
+  /**
+   * Get child issues of a parent issue
+   * Uses JQL search: parent = KEY
+   */
+  async getChildIssues(input) {
+    const parentKey = this.tracker.normalizeIdentifier(input.number);
+    const host = this.tracker.getConfig().host;
+    const issues = await this.tracker.getApiClient().searchIssues(`parent = "${escapeJql(parentKey)}"`);
+    return issues.map((issue) => ({
+      id: issue.key,
+      title: issue.fields.summary,
+      url: `${host}/browse/${issue.key}`,
+      state: issue.fields.status.name.toLowerCase()
+    }));
+  }
+  /**
+   * Close an issue by transitioning to "Done" state
+   */
+  async closeIssue(input) {
+    const issueKey = this.tracker.normalizeIdentifier(input.number);
+    await this.tracker.closeIssue(issueKey);
+  }
+  /**
+   * Reopen a closed issue
+   */
+  async reopenIssue(input) {
+    const issueKey = this.tracker.normalizeIdentifier(input.number);
+    await this.tracker.reopenIssue(issueKey);
+  }
+  /**
+   * Edit an issue's properties
+   * State changes are delegated to closeIssue/reopenIssue
+   */
+  async editIssue(input) {
+    const { number, title, body, state } = input;
+    if (state === "closed") {
+      await this.closeIssue({ number });
+    } else if (state === "open") {
+      await this.reopenIssue({ number });
+    }
+    if (title !== void 0 || body !== void 0) {
+      const issueKey = this.tracker.normalizeIdentifier(number);
+      await this.tracker.getApiClient().updateIssue(issueKey, {
+        ...title !== void 0 && { summary: title },
+        ...body !== void 0 && { description: body }
+      });
+    }
+  }
 };
 
 // src/mcp/IssueManagementProviderFactory.ts
 var IssueManagementProviderFactory = class {
   /**
    * Create an issue management provider based on the provider type
+   * @param provider - The provider type (github, linear, jira)
+   * @param settings - Required for Jira provider, optional for others
    */
-  static create(provider) {
+  static create(provider, settings) {
     switch (provider) {
       case "github":
         return new GitHubIssueManagementProvider();
       case "linear":
         return new LinearIssueManagementProvider();
+      case "jira":
+        if (!settings) {
+          throw new Error("Settings required for Jira provider");
+        }
+        return new JiraIssueManagementProvider(settings);
       default:
         throw new Error(`Unsupported issue management provider: ${provider}`);
     }
@@ -962,4 +1433,4 @@ var IssueManagementProviderFactory = class {
 export {
   IssueManagementProviderFactory
 };
-//# sourceMappingURL=chunk-ULSWCPQG.js.map
+//# sourceMappingURL=chunk-JO2LZ6EQ.js.map