@iloom/cli 0.7.5 → 0.8.0

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

@@ -125,7 +125,7 @@ async function executeGhCommand(args, options) {
     timeout: (options == null ? void 0 : options.timeout) ?? 3e4,
     encoding: "utf8"
   });
-  const isJson = args.includes("--json") || args.includes("--jq") || args.includes("--format") && args[args.indexOf("--format") + 1] === "json";
+  const isJson = args.includes("--json") || args.includes("--jq") || args.includes("--format") && args[args.indexOf("--format") + 1] === "json" || args[0] === "api" && args[1] === "graphql";
   const data = isJson ? JSON.parse(result.stdout) : result.stdout;
   return data;
 }
@@ -235,6 +235,386 @@ async function addSubIssue(parentNodeId, childNodeId) {
     `subIssueId=${childNodeId}`
   ]);
 }
+async function getSubIssues(issueNumber, repo) {
+  var _a, _b;
+  logger.debug("Fetching GitHub sub-issues", { issueNumber, repo });
+  const parentNodeId = await getIssueNodeId(issueNumber, repo);
+  const query = `
+		query getSubIssues($parentId: ID!) {
+			node(id: $parentId) {
+				... on Issue {
+					subIssues(first: 100) {
+						nodes {
+							number
+							title
+							url
+							state
+						}
+					}
+				}
+			}
+		}
+	`;
+  try {
+    const result = await executeGhCommand([
+      "api",
+      "graphql",
+      "-H",
+      "GraphQL-Features: sub_issues",
+      "-f",
+      `query=${query}`,
+      "-F",
+      `parentId=${parentNodeId}`
+    ]);
+    const subIssues = ((_b = (_a = result.data.node) == null ? void 0 : _a.subIssues) == null ? void 0 : _b.nodes) ?? [];
+    return subIssues.map((issue) => ({
+      id: String(issue.number),
+      title: issue.title,
+      url: issue.url,
+      state: issue.state.toLowerCase()
+    }));
+  } catch (error) {
+    if (error instanceof Error) {
+      const errorMessage = error.message;
+      const stderr = "stderr" in error ? error.stderr ?? "" : "";
+      const combinedError = `${errorMessage} ${stderr}`;
+      if (combinedError.includes("sub_issues") || combinedError.includes("null")) {
+        return [];
+      }
+    }
+    throw error;
+  }
+}
+async function getIssueDatabaseId(issueNumber, repo) {
+  logger.debug("Fetching GitHub issue database ID", { issueNumber, repo });
+  const apiPath = repo ? `repos/${repo}/issues/${issueNumber}` : `repos/:owner/:repo/issues/${issueNumber}`;
+  const result = await executeGhCommand([
+    "api",
+    apiPath,
+    "--jq",
+    "{id: .id}"
+  ]);
+  return result.id;
+}
+async function getIssueDependencies(issueNumber, direction, repo) {
+  logger.debug("Fetching GitHub issue dependencies", { issueNumber, direction, repo });
+  const apiPath = repo ? `repos/${repo}/issues/${issueNumber}/dependencies/${direction}` : `repos/:owner/:repo/issues/${issueNumber}/dependencies/${direction}`;
+  try {
+    const result = await executeGhCommand([
+      "api",
+      "-H",
+      "Accept: application/vnd.github+json",
+      "-H",
+      "X-GitHub-Api-Version: 2022-11-28",
+      "--jq",
+      ".",
+      apiPath
+    ]);
+    return (result ?? []).map((dep) => ({
+      id: String(dep.number),
+      databaseId: dep.id,
+      title: dep.title,
+      url: dep.html_url,
+      state: dep.state
+    }));
+  } catch (error) {
+    if (error instanceof Error) {
+      const errorMessage = error.message;
+      const stderr = "stderr" in error ? error.stderr ?? "" : "";
+      const combinedError = `${errorMessage} ${stderr}`;
+      if (combinedError.includes("404") && combinedError.includes("dependencies")) {
+        return [];
+      }
+    }
+    throw error;
+  }
+}
+async function createIssueDependency(blockedIssueNumber, blockingIssueDatabaseId, repo) {
+  logger.debug("Creating GitHub issue dependency", { blockedIssueNumber, blockingIssueDatabaseId, repo });
+  const apiPath = repo ? `repos/${repo}/issues/${blockedIssueNumber}/dependencies/blocked_by` : `repos/:owner/:repo/issues/${blockedIssueNumber}/dependencies/blocked_by`;
+  try {
+    await executeGhCommand([
+      "api",
+      "-X",
+      "POST",
+      "-H",
+      "Accept: application/vnd.github+json",
+      "-H",
+      "X-GitHub-Api-Version: 2022-11-28",
+      apiPath,
+      "-F",
+      `issue_id=${blockingIssueDatabaseId}`
+    ]);
+  } catch (error) {
+    if (error instanceof Error) {
+      const errorMessage = error.message;
+      const stderr = "stderr" in error ? error.stderr ?? "" : "";
+      const combinedError = `${errorMessage} ${stderr}`;
+      if (combinedError.includes("422") || combinedError.includes("already exists") || combinedError.includes("Unprocessable Entity")) {
+        throw new Error(`Dependency already exists: issue #${blockedIssueNumber} is already blocked by the specified issue`);
+      }
+      if (combinedError.includes("404") || combinedError.includes("Not Found")) {
+        throw new Error(`Issue not found: unable to create dependency for issue #${blockedIssueNumber}. The issue may not exist or you may not have access to it.`);
+      }
+      if (combinedError.includes("403") || combinedError.includes("Forbidden") || combinedError.includes("not enabled")) {
+        throw new Error(`Dependencies feature not enabled: the repository may not have issue dependencies enabled. This feature requires GitHub Enterprise or specific repository settings.`);
+      }
+    }
+    throw error;
+  }
+}
+async function removeIssueDependency(blockedIssueNumber, blockingIssueDatabaseId, repo) {
+  logger.debug("Removing GitHub issue dependency", { blockedIssueNumber, blockingIssueDatabaseId, repo });
+  const apiPath = repo ? `repos/${repo}/issues/${blockedIssueNumber}/dependencies/blocked_by/${blockingIssueDatabaseId}` : `repos/:owner/:repo/issues/${blockedIssueNumber}/dependencies/blocked_by/${blockingIssueDatabaseId}`;
+  await executeGhCommand([
+    "api",
+    "-X",
+    "DELETE",
+    "-H",
+    "Accept: application/vnd.github+json",
+    "-H",
+    "X-GitHub-Api-Version: 2022-11-28",
+    apiPath
+  ]);
+}
+
+// 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) {
@@ -314,6 +694,12 @@ 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;
   }
   /**
@@ -382,6 +768,12 @@ 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;
   }
   /**
@@ -401,9 +793,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 },
@@ -476,10 +869,76 @@ var GitHubIssueManagementProvider = class {
       number: childNumber
     };
   }
+  /**
+   * Create a blocking dependency between two issues (A blocks B)
+   * Uses GitHub's sub-issues API: blocking issue becomes parent, blocked issue becomes sub-issue
+   */
+  async createDependency(input) {
+    const { blockingIssue, blockedIssue, repo } = input;
+    const blockingNumber = parseInt(blockingIssue, 10);
+    if (isNaN(blockingNumber)) {
+      throw new Error(`Invalid GitHub issue number: ${blockingIssue}. GitHub issue IDs must be numeric.`);
+    }
+    const blockedNumber = parseInt(blockedIssue, 10);
+    if (isNaN(blockedNumber)) {
+      throw new Error(`Invalid GitHub issue number: ${blockedIssue}. GitHub issue IDs must be numeric.`);
+    }
+    const blockingDatabaseId = await getIssueDatabaseId(blockingNumber, repo);
+    await createIssueDependency(blockedNumber, blockingDatabaseId, repo);
+  }
+  /**
+   * Get dependencies for an issue
+   */
+  async getDependencies(input) {
+    const { number, direction, repo } = input;
+    const issueNumber = parseInt(number, 10);
+    if (isNaN(issueNumber)) {
+      throw new Error(`Invalid GitHub issue number: ${number}. GitHub issue IDs must be numeric.`);
+    }
+    const result = {
+      blocking: [],
+      blockedBy: []
+    };
+    if (direction === "blocking" || direction === "both") {
+      result.blocking = await getIssueDependencies(issueNumber, "blocking", repo);
+    }
+    if (direction === "blocked_by" || direction === "both") {
+      result.blockedBy = await getIssueDependencies(issueNumber, "blocked_by", repo);
+    }
+    return result;
+  }
+  /**
+   * Remove a blocking dependency between two issues (A blocks B)
+   * Uses GitHub's sub-issues API: blocking issue is parent, blocked issue is sub-issue
+   */
+  async removeDependency(input) {
+    const { blockingIssue, blockedIssue, repo } = input;
+    const blockingNumber = parseInt(blockingIssue, 10);
+    if (isNaN(blockingNumber)) {
+      throw new Error(`Invalid GitHub issue number: ${blockingIssue}. GitHub issue IDs must be numeric.`);
+    }
+    const blockedNumber = parseInt(blockedIssue, 10);
+    if (isNaN(blockedNumber)) {
+      throw new Error(`Invalid GitHub issue number: ${blockedIssue}. GitHub issue IDs must be numeric.`);
+    }
+    const blockingDatabaseId = await getIssueDatabaseId(blockingNumber, repo);
+    await removeIssueDependency(blockedNumber, blockingDatabaseId, repo);
+  }
+  /**
+   * Get child issues (sub-issues) of a parent issue
+   */
+  async getChildIssues(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.`);
+    }
+    return await getSubIssues(issueNumber, repo);
+  }
 };
 
 // src/utils/linear.ts
-import { LinearClient } from "@linear/sdk";
+import { LinearClient, IssueRelationType } from "@linear/sdk";
 
 // src/types/linear.ts
 var LinearServiceError = class _LinearServiceError extends Error {
@@ -749,10 +1208,161 @@ async function fetchLinearIssueComments(identifier) {
     handleLinearError(error, "fetchLinearIssueComments");
   }
 }
+async function getLinearChildIssues(identifier) {
+  try {
+    logger.debug(`Fetching child issues 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 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 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/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
@@ -888,7 +1498,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 = [
@@ -900,7 +1510,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}`);
   }
 };
 
@@ -949,6 +1559,12 @@ 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;
   }
   /**
@@ -982,9 +1598,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
@@ -1057,6 +1674,42 @@ var LinearIssueManagementProvider = class {
       url: result.url
     };
   }
+  /**
+   * Create a blocking dependency between two issues
+   */
+  async createDependency(input) {
+    const { blockingIssue, blockedIssue } = input;
+    const [blockingIssueData, blockedIssueData] = await Promise.all([
+      fetchLinearIssue(blockingIssue),
+      fetchLinearIssue(blockedIssue)
+    ]);
+    await createLinearIssueRelation(blockingIssueData.id, blockedIssueData.id);
+  }
+  /**
+   * Get dependencies for an issue
+   */
+  async getDependencies(input) {
+    const { number, direction } = input;
+    return await getLinearIssueDependencies(number, direction);
+  }
+  /**
+   * Remove a blocking dependency between two issues
+   */
+  async removeDependency(input) {
+    const { blockingIssue, blockedIssue } = input;
+    const relationId = await findLinearIssueRelation(blockingIssue, blockedIssue);
+    if (!relationId) {
+      throw new Error(`No blocking dependency found from ${blockingIssue} to ${blockedIssue}`);
+    }
+    await deleteLinearIssueRelation(relationId);
+  }
+  /**
+   * Get child issues of a parent issue
+   */
+  async getChildIssues(input) {
+    const { number } = input;
+    return await getLinearChildIssues(number);
+  }
 };
 
 // src/mcp/IssueManagementProviderFactory.ts
@@ -1471,6 +2124,178 @@ server.registerTool(
     }
   }
 );
+var dependencyResultSchema = z.object({
+  id: z.string().describe("Issue identifier"),
+  title: z.string().describe("Issue title"),
+  url: z.string().describe("Issue URL"),
+  state: z.string().describe("Issue state")
+});
+server.registerTool(
+  "create_dependency",
+  {
+    title: "Create Dependency",
+    description: 'Create a blocking dependency between two issues. The blockingIssue will block the blockedIssue. For GitHub: uses the sub-issue API. For Linear: creates a "blocks" relation.',
+    inputSchema: {
+      blockingIssue: z.string().describe('The issue that blocks (GitHub issue number or Linear identifier like "ENG-123")'),
+      blockedIssue: z.string().describe('The issue being blocked (GitHub issue number or Linear identifier like "ENG-123")'),
+      repo: z.string().optional().describe(
+        'Optional repository in "owner/repo" format or full GitHub URL. When not provided, uses the current repository. GitHub only.'
+      )
+    },
+    outputSchema: {
+      success: z.boolean().describe("Whether the dependency was created successfully")
+    }
+  },
+  async ({ blockingIssue, blockedIssue, repo }) => {
+    console.error(`Creating dependency: ${blockingIssue} blocks ${blockedIssue}${repo ? ` in ${repo}` : ""}`);
+    try {
+      const provider = IssueManagementProviderFactory.create(
+        process.env.ISSUE_PROVIDER
+      );
+      await provider.createDependency({ blockingIssue, blockedIssue, repo });
+      console.error(`Dependency created successfully: ${blockingIssue} -> ${blockedIssue}`);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ success: true })
+          }
+        ],
+        structuredContent: { success: true }
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      console.error(`Failed to create dependency: ${errorMessage}`);
+      throw new Error(`Failed to create dependency: ${errorMessage}`);
+    }
+  }
+);
+server.registerTool(
+  "get_dependencies",
+  {
+    title: "Get Dependencies",
+    description: "Get blocking/blocked_by dependencies for an issue. Returns lists of issues that this issue blocks and/or is blocked by.",
+    inputSchema: {
+      number: z.string().describe('Issue identifier (GitHub issue number or Linear identifier like "ENG-123")'),
+      direction: z.enum(["blocking", "blocked_by", "both"]).describe('Which dependencies to fetch: "blocking" for issues this blocks, "blocked_by" for issues blocking this, "both" for all'),
+      repo: z.string().optional().describe(
+        'Optional repository in "owner/repo" format or full GitHub URL. When not provided, uses the current repository. GitHub only.'
+      )
+    },
+    outputSchema: {
+      blocking: z.array(dependencyResultSchema).describe("Issues that this issue blocks"),
+      blockedBy: z.array(dependencyResultSchema).describe("Issues that block this issue")
+    }
+  },
+  async ({ number, direction, repo }) => {
+    console.error(`Getting dependencies for ${number} (direction: ${direction})${repo ? ` in ${repo}` : ""}`);
+    try {
+      const provider = IssueManagementProviderFactory.create(
+        process.env.ISSUE_PROVIDER
+      );
+      const result = await provider.getDependencies({ number, direction, repo });
+      console.error(`Dependencies fetched: ${result.blocking.length} blocking, ${result.blockedBy.length} blocked_by`);
+      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 get dependencies: ${errorMessage}`);
+      throw new Error(`Failed to get dependencies: ${errorMessage}`);
+    }
+  }
+);
+server.registerTool(
+  "remove_dependency",
+  {
+    title: "Remove Dependency",
+    description: "Remove a blocking dependency between two issues. The blockingIssue will no longer block the blockedIssue.",
+    inputSchema: {
+      blockingIssue: z.string().describe('The issue that blocks (GitHub issue number or Linear identifier like "ENG-123")'),
+      blockedIssue: z.string().describe('The issue being blocked (GitHub issue number or Linear identifier like "ENG-123")'),
+      repo: z.string().optional().describe(
+        'Optional repository in "owner/repo" format or full GitHub URL. When not provided, uses the current repository. GitHub only.'
+      )
+    },
+    outputSchema: {
+      success: z.boolean().describe("Whether the dependency was removed successfully")
+    }
+  },
+  async ({ blockingIssue, blockedIssue, repo }) => {
+    console.error(`Removing dependency: ${blockingIssue} blocks ${blockedIssue}${repo ? ` in ${repo}` : ""}`);
+    try {
+      const provider = IssueManagementProviderFactory.create(
+        process.env.ISSUE_PROVIDER
+      );
+      await provider.removeDependency({ blockingIssue, blockedIssue, repo });
+      console.error(`Dependency removed successfully: ${blockingIssue} -> ${blockedIssue}`);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ success: true })
+          }
+        ],
+        structuredContent: { success: true }
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      console.error(`Failed to remove dependency: ${errorMessage}`);
+      throw new Error(`Failed to remove dependency: ${errorMessage}`);
+    }
+  }
+);
+var childIssueResultSchema = z.object({
+  id: z.string().describe("Issue identifier"),
+  title: z.string().describe("Issue title"),
+  url: z.string().describe("Issue URL"),
+  state: z.string().describe("Issue state")
+});
+server.registerTool(
+  "get_child_issues",
+  {
+    title: "Get Child Issues",
+    description: "Get child issues (sub-issues) of a parent issue. Returns a list of issues that are children of the specified parent.",
+    inputSchema: {
+      number: z.string().describe('Parent issue identifier (GitHub issue number or Linear identifier like "ENG-123")'),
+      repo: z.string().optional().describe(
+        'Optional repository in "owner/repo" format or full GitHub URL. When not provided, uses the current repository. GitHub only.'
+      )
+    },
+    outputSchema: {
+      children: z.array(childIssueResultSchema).describe("Child issues of the parent")
+    }
+  },
+  async ({ number, repo }) => {
+    console.error(`Getting child issues for ${number}${repo ? ` in ${repo}` : ""}`);
+    try {
+      const provider = IssueManagementProviderFactory.create(
+        process.env.ISSUE_PROVIDER
+      );
+      const result = await provider.getChildIssues({ number, repo });
+      console.error(`Child issues fetched: ${result.length} children`);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ children: result })
+          }
+        ],
+        structuredContent: { children: result }
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      console.error(`Failed to get child issues: ${errorMessage}`);
+      throw new Error(`Failed to get child issues: ${errorMessage}`);
+    }
+  }
+);
 async function main() {
   console.error("Starting Issue Management MCP Server...");
   const provider = validateEnvironment();