@iloom/cli 0.7.4 → 0.7.6

package/dist/{init-YDKOPB54.js → init-S6IEGRSX.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   InitCommand
-} from "./chunk-33P5VSKS.js";
+} from "./chunk-C7YW5IMS.js";
 import "./chunk-Q7POFB5Q.js";
 import "./chunk-F2PWIRV4.js";
 import "./chunk-N7FVXZNI.js";
@@ -12,10 +12,10 @@ import "./chunk-ZA575VLF.js";
 import "./chunk-WFQ5CLTR.js";
 import "./chunk-VWGKGNJP.js";
 import "./chunk-ZX3GTM7O.js";
-import "./chunk-ITIXKM24.js";
+import "./chunk-IGKPPACU.js";
 import "./chunk-6MLEBAYZ.js";
 import "./chunk-VT4PDUYT.js";
 export {
   InitCommand
 };
-//# sourceMappingURL=init-YDKOPB54.js.map
+//# sourceMappingURL=init-S6IEGRSX.js.map

package/dist/mcp/issue-management-server.js

@@ -236,6 +236,244 @@ async function addSubIssue(parentNodeId, childNodeId) {
   ]);
 }
 
+// src/utils/image-processor.ts
+import { tmpdir } from "os";
+import { join, extname } from "path";
+import { existsSync as existsSync2, mkdirSync, createWriteStream, unlinkSync } from "fs";
+import { pipeline } from "stream/promises";
+import { Readable } from "stream";
+import { createHash } from "crypto";
+import { execa as execa3 } from "execa";
+var SUPPORTED_EXTENSIONS = [".png", ".jpg", ".jpeg", ".gif", ".webp", ".svg"];
+var MAX_IMAGE_SIZE = 10 * 1024 * 1024;
+var REQUEST_TIMEOUT_MS = 3e4;
+var CACHE_DIR = join(tmpdir(), "iloom-images");
+var cachedGitHubToken;
+function extractMarkdownImageUrls(content) {
+  if (!content) {
+    return [];
+  }
+  const matches = [];
+  const markdownRegex = /!\[([^\]]*)\]\(((?:[^()\s]|\((?:[^()\s]|\([^()]*\))*\))+)\)/g;
+  let match;
+  while ((match = markdownRegex.exec(content)) !== null) {
+    const url = match[2];
+    if (url) {
+      matches.push({
+        fullMatch: match[0],
+        url,
+        isMarkdown: true
+      });
+    }
+  }
+  const htmlImgRegex = /<img\s+[^>]*src=["']([^"']+)["'][^>]*\/?>/gi;
+  while ((match = htmlImgRegex.exec(content)) !== null) {
+    const url = match[1];
+    if (url) {
+      matches.push({
+        fullMatch: match[0],
+        url,
+        isMarkdown: false
+      });
+    }
+  }
+  return matches;
+}
+function isAuthenticatedImageUrl(url) {
+  try {
+    const parsedUrl = new URL(url);
+    const hostname = parsedUrl.hostname.toLowerCase();
+    if (hostname === "uploads.linear.app") {
+      return true;
+    }
+    if (hostname === "private-user-images.githubusercontent.com") {
+      return true;
+    }
+    if (hostname === "github.com" && parsedUrl.pathname.startsWith("/user-attachments/assets/")) {
+      return true;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+function getExtensionFromUrl(url) {
+  try {
+    const parsedUrl = new URL(url);
+    const pathname = parsedUrl.pathname;
+    const ext = extname(pathname).toLowerCase();
+    if (SUPPORTED_EXTENSIONS.includes(ext)) {
+      return ext;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function getCacheKey(url) {
+  const parsedUrl = new URL(url);
+  if (parsedUrl.hostname === "private-user-images.githubusercontent.com") {
+    parsedUrl.searchParams.delete("jwt");
+  }
+  const stableUrl = parsedUrl.toString();
+  const hash = createHash("sha256").update(stableUrl).digest("hex").slice(0, 16);
+  const ext = getExtensionFromUrl(url) ?? ".png";
+  return `${hash}${ext}`;
+}
+function getCachedImagePath(url) {
+  const cacheKey = getCacheKey(url);
+  const cachedPath = join(CACHE_DIR, cacheKey);
+  if (existsSync2(cachedPath)) {
+    return cachedPath;
+  }
+  return void 0;
+}
+async function getAuthToken(provider) {
+  if (provider === "github") {
+    if (cachedGitHubToken !== void 0) {
+      return cachedGitHubToken;
+    }
+    try {
+      const result = await execa3("gh", ["auth", "token"]);
+      cachedGitHubToken = result.stdout.trim();
+      return cachedGitHubToken;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      logger.warn(`Failed to get GitHub auth token via gh CLI: ${message}`);
+      return void 0;
+    }
+  }
+  if (provider === "linear") {
+    return process.env.LINEAR_API_TOKEN;
+  }
+  return void 0;
+}
+async function downloadAndSaveImage(url, destPath, authHeader) {
+  const headers = {};
+  if (authHeader) {
+    headers["Authorization"] = authHeader;
+  }
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+  try {
+    const response = await fetch(url, { headers, signal: controller.signal });
+    if (!response.ok) {
+      throw new Error(`Failed to download image: ${response.status} ${response.statusText}`);
+    }
+    const contentLength = response.headers.get("Content-Length");
+    if (contentLength && parseInt(contentLength, 10) > MAX_IMAGE_SIZE) {
+      throw new Error(`Image too large: ${contentLength} bytes exceeds ${MAX_IMAGE_SIZE} byte limit`);
+    }
+    if (!response.body) {
+      throw new Error("Response body is null");
+    }
+    const reader = response.body.getReader();
+    let bytesWritten = 0;
+    const nodeReadable = new Readable({
+      async read() {
+        try {
+          const { done, value } = await reader.read();
+          if (done) {
+            this.push(null);
+            return;
+          }
+          bytesWritten += value.byteLength;
+          if (bytesWritten > MAX_IMAGE_SIZE) {
+            reader.cancel();
+            this.destroy(new Error(`Image too large: ${bytesWritten} bytes exceeds ${MAX_IMAGE_SIZE} byte limit`));
+            return;
+          }
+          this.push(Buffer.from(value));
+        } catch (err) {
+          this.destroy(err instanceof Error ? err : new Error(String(err)));
+        }
+      }
+    });
+    if (!existsSync2(CACHE_DIR)) {
+      mkdirSync(CACHE_DIR, { recursive: true });
+    }
+    const writeStream = createWriteStream(destPath);
+    try {
+      await pipeline(nodeReadable, writeStream);
+    } catch (pipelineError) {
+      try {
+        if (existsSync2(destPath)) {
+          unlinkSync(destPath);
+        }
+      } catch {
+      }
+      throw pipelineError;
+    }
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new Error(`Image download timed out after ${REQUEST_TIMEOUT_MS}ms`);
+    }
+    throw error;
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+function getCacheDestPath(url) {
+  if (!existsSync2(CACHE_DIR)) {
+    mkdirSync(CACHE_DIR, { recursive: true });
+  }
+  const cacheKey = getCacheKey(url);
+  return join(CACHE_DIR, cacheKey);
+}
+function rewriteMarkdownUrls(content, urlMap) {
+  let result = content;
+  for (const [originalUrl, localPath] of urlMap) {
+    const escapedUrl = originalUrl.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const urlRegex = new RegExp(escapedUrl, "g");
+    result = result.replace(urlRegex, localPath);
+  }
+  return result;
+}
+async function processMarkdownImages(content, provider) {
+  if (!content) {
+    return "";
+  }
+  const images = extractMarkdownImageUrls(content);
+  if (images.length === 0) {
+    return content;
+  }
+  const authImages = images.filter((img) => isAuthenticatedImageUrl(img.url));
+  if (authImages.length === 0) {
+    return content;
+  }
+  const authToken = await getAuthToken(provider);
+  const uniqueUrls = [...new Set(authImages.map((img) => img.url))];
+  const urlMap = /* @__PURE__ */ new Map();
+  const downloadPromises = uniqueUrls.map(async (url) => {
+    try {
+      const cachedPath = getCachedImagePath(url);
+      if (cachedPath) {
+        logger.debug(`Using cached image: ${cachedPath}`);
+        return { url, localPath: cachedPath };
+      }
+      logger.debug(`Downloading image: ${url}`);
+      const destPath = getCacheDestPath(url);
+      await downloadAndSaveImage(
+        url,
+        destPath,
+        authToken ? `Bearer ${authToken}` : void 0
+      );
+      return { url, localPath: destPath };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      logger.warn(`Failed to download image ${url}: ${message}`);
+      return null;
+    }
+  });
+  const results = await Promise.all(downloadPromises);
+  for (const result of results) {
+    if (result !== null) {
+      urlMap.set(result.url, result.localPath);
+    }
+  }
+  return rewriteMarkdownUrls(content, urlMap);
+}
+
 // src/mcp/GitHubIssueManagementProvider.ts
 function normalizeAuthor(author) {
   if (!author) return null;
@@ -314,6 +552,86 @@ var GitHubIssueManagementProvider = class {
         ...comment.updatedAt && { updatedAt: comment.updatedAt }
       }));
     }
+    result.body = await processMarkdownImages(result.body, "github");
+    if (result.comments) {
+      for (const comment of result.comments) {
+        comment.body = await processMarkdownImages(comment.body, "github");
+      }
+    }
+    return result;
+  }
+  /**
+   * Fetch pull request details using gh CLI
+   * Normalizes GitHub-specific fields to provider-agnostic format
+   */
+  async getPR(input) {
+    const { number, includeComments = true, repo } = input;
+    const prNumber = parseInt(number, 10);
+    if (isNaN(prNumber)) {
+      throw new Error(`Invalid GitHub PR number: ${number}. GitHub PR IDs must be numeric.`);
+    }
+    const baseFields = "number,title,body,state,url,author,headRefName,baseRefName,files,commits";
+    const fields = includeComments ? `${baseFields},comments` : baseFields;
+    const args = [
+      "pr",
+      "view",
+      String(prNumber),
+      "--json",
+      fields
+    ];
+    if (repo) {
+      args.push("--repo", repo);
+    }
+    const raw = await executeGhCommand(args);
+    const result = {
+      // Core fields
+      id: String(raw.number),
+      number: raw.number,
+      title: raw.title,
+      body: raw.body,
+      state: raw.state,
+      url: raw.url,
+      // Normalized author
+      author: normalizeAuthor(raw.author),
+      // PR-specific fields
+      headRefName: raw.headRefName,
+      baseRefName: raw.baseRefName,
+      // Optional files
+      ...raw.files && {
+        files: raw.files
+      },
+      // Optional commits - normalize author
+      ...raw.commits && {
+        commits: raw.commits.map((commit) => {
+          var _a;
+          return {
+            oid: commit.oid,
+            messageHeadline: commit.messageHeadline,
+            author: ((_a = commit.authors) == null ? void 0 : _a[0]) ? {
+              id: commit.authors[0].email,
+              displayName: commit.authors[0].name,
+              name: commit.authors[0].name,
+              email: commit.authors[0].email
+            } : null
+          };
+        })
+      }
+    };
+    if (raw.comments !== void 0) {
+      result.comments = raw.comments.map((comment) => ({
+        id: extractNumericIdFromUrl(comment.url),
+        body: comment.body,
+        createdAt: comment.createdAt,
+        author: normalizeAuthor(comment.author),
+        ...comment.updatedAt && { updatedAt: comment.updatedAt }
+      }));
+    }
+    result.body = await processMarkdownImages(result.body, "github");
+    if (result.comments) {
+      for (const comment of result.comments) {
+        comment.body = await processMarkdownImages(comment.body, "github");
+      }
+    }
     return result;
   }
   /**
@@ -333,9 +651,10 @@ var GitHubIssueManagementProvider = class {
       "--jq",
       "{id: .id, body: .body, user: .user, created_at: .created_at, updated_at: .updated_at, html_url: .html_url, reactions: .reactions}"
     ]);
+    const processedBody = await processMarkdownImages(raw.body, "github");
     return {
       id: String(raw.id),
-      body: raw.body,
+      body: processedBody,
       author: normalizeAuthor(raw.user),
       created_at: raw.created_at,
       ...raw.updated_at && { updated_at: raw.updated_at },
@@ -684,7 +1003,7 @@ async function fetchLinearIssueComments(identifier) {
 
 // src/utils/linear-markup-converter.ts
 import { appendFileSync } from "fs";
-import { join, dirname, basename, extname } from "path";
+import { join as join2, dirname, basename, extname as extname2 } from "path";
 var LinearMarkupConverter = class {
   /**
    * Convert HTML details/summary blocks to Linear's collapsible format
@@ -820,7 +1139,7 @@ ${content}
    */
   static getTimestampedLogPath(logFilePath) {
     const dir = dirname(logFilePath);
-    const ext = extname(logFilePath);
+    const ext = extname2(logFilePath);
     const base = basename(logFilePath, ext);
     const now = /* @__PURE__ */ new Date();
     const timestamp = [
@@ -832,7 +1151,7 @@ ${content}
       String(now.getMinutes()).padStart(2, "0"),
       String(now.getSeconds()).padStart(2, "0")
     ].join("");
-    return join(dir, `${base}-${timestamp}${ext}`);
+    return join2(dir, `${base}-${timestamp}${ext}`);
   }
 };
 
@@ -881,8 +1200,21 @@ var LinearIssueManagementProvider = class {
       } catch {
       }
     }
+    result.body = await processMarkdownImages(result.body, "linear");
+    if (result.comments) {
+      for (const comment of result.comments) {
+        comment.body = await processMarkdownImages(comment.body, "linear");
+      }
+    }
     return result;
   }
+  /**
+   * Fetch pull request details
+   * Linear does not support PRs - this throws an error directing to use GitHub
+   */
+  async getPR(_input) {
+    throw new Error("Linear does not support pull requests. PRs exist only on GitHub. Use the GitHub provider for PR operations.");
+  }
   /**
    * Fetch comments for an issue
    */
@@ -907,9 +1239,10 @@ var LinearIssueManagementProvider = class {
   async getComment(input) {
     const { commentId } = input;
     const raw = await getLinearComment(commentId);
+    const processedBody = await processMarkdownImages(raw.body, "linear");
     return {
       id: raw.id,
-      body: raw.body,
+      body: processedBody,
       author: null,
       // Linear SDK doesn't return comment author info in basic fetch
       created_at: raw.createdAt
@@ -1104,6 +1437,80 @@ server.registerTool(
     }
   }
 );
+server.registerTool(
+  "get_pr",
+  {
+    title: "Get Pull Request",
+    description: "Fetch pull request details including title, body, comments, files, commits, and branch information. PRs only exist on GitHub, so this tool always uses GitHub regardless of configured issue tracker. Author fields have normalized core fields: { id, displayName } plus provider-specific fields.",
+    inputSchema: {
+      number: z.string().describe("The PR number"),
+      includeComments: z.boolean().optional().describe("Whether to include comments (default: true)"),
+      repo: z.string().optional().describe(
+        'Optional repository in "owner/repo" format or full GitHub URL. When not provided, uses the current repository.'
+      )
+    },
+    outputSchema: {
+      // Core validated fields
+      id: z.string().describe("PR identifier"),
+      number: z.number().describe("PR number"),
+      title: z.string().describe("PR title"),
+      body: z.string().describe("PR body/description"),
+      state: z.string().describe("PR state (OPEN, CLOSED, MERGED)"),
+      url: z.string().describe("PR URL"),
+      // Branch info
+      headRefName: z.string().describe("Source branch name"),
+      baseRefName: z.string().describe("Target branch name"),
+      // Flexible author - core fields + passthrough
+      author: flexibleAuthorSchema.nullable().describe(
+        "PR author with normalized { id, displayName } plus provider-specific fields"
+      ),
+      // Optional flexible arrays
+      files: z.array(
+        z.object({
+          path: z.string(),
+          additions: z.number(),
+          deletions: z.number()
+        }).passthrough()
+      ).optional().describe("Changed files in the PR"),
+      commits: z.array(
+        z.object({
+          oid: z.string(),
+          messageHeadline: z.string(),
+          author: flexibleAuthorSchema.nullable()
+        }).passthrough()
+      ).optional().describe("Commits in the PR"),
+      comments: z.array(
+        z.object({
+          id: z.string(),
+          body: z.string(),
+          author: flexibleAuthorSchema.nullable(),
+          createdAt: z.string()
+        }).passthrough()
+      ).optional().describe("PR comments")
+    }
+  },
+  async ({ number, includeComments, repo }) => {
+    console.error(`Fetching PR ${number}${repo ? ` from ${repo}` : ""}`);
+    try {
+      const provider = new GitHubIssueManagementProvider();
+      const result = await provider.getPR({ number, includeComments, repo });
+      console.error(`PR fetched successfully: #${result.number} - ${result.title}`);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result)
+          }
+        ],
+        structuredContent: result
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      console.error(`Failed to fetch PR: ${errorMessage}`);
+      throw new Error(`Failed to fetch PR: ${errorMessage}`);
+    }
+  }
+);
 server.registerTool(
   "get_comment",
   {
@@ -1169,9 +1576,8 @@ server.registerTool(
   async ({ number, body, type }) => {
     console.error(`Creating ${type} comment on ${number}`);
     try {
-      const provider = IssueManagementProviderFactory.create(
-        process.env.ISSUE_PROVIDER
-      );
+      const providerType = type === "pr" ? "github" : process.env.ISSUE_PROVIDER;
+      const provider = IssueManagementProviderFactory.create(providerType);
       const result = await provider.createComment({ number, body, type });
       console.error(
         `Comment created successfully: ${result.id} at ${result.url}`
@@ -1200,7 +1606,8 @@ server.registerTool(
     inputSchema: {
       commentId: z.string().describe("The comment identifier to update"),
       number: z.string().describe("The issue or PR identifier (context for providers that need it)"),
-      body: z.string().describe("The updated comment body (markdown supported)")
+      body: z.string().describe("The updated comment body (markdown supported)"),
+      type: z.enum(["issue", "pr"]).optional().describe("Optional type to route PR comments to GitHub regardless of configured provider")
     },
     outputSchema: {
       id: z.string(),
@@ -1208,12 +1615,11 @@ server.registerTool(
       updated_at: z.string().optional()
     }
   },
-  async ({ commentId, number, body }) => {
-    console.error(`Updating comment ${commentId} on issue ${number}`);
+  async ({ commentId, number, body, type }) => {
+    console.error(`Updating comment ${commentId} on ${type === "pr" ? "PR" : "issue"} ${number}`);
     try {
-      const provider = IssueManagementProviderFactory.create(
-        process.env.ISSUE_PROVIDER
-      );
+      const providerType = type === "pr" ? "github" : process.env.ISSUE_PROVIDER;
+      const provider = IssueManagementProviderFactory.create(providerType);
       const result = await provider.updateComment({ commentId, number, body });
       console.error(
         `Comment updated successfully: ${result.id} at ${result.url}`