@iloom/cli 0.7.6 → 0.8.0

package/dist/init-MZBIXQ7V.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+import {
+  InitCommand
+} from "./chunk-RODL2HVY.js";
+import "./chunk-Q7POFB5Q.js";
+import "./chunk-BYUMEDDD.js";
+import "./chunk-4BSXZ5YZ.js";
+import "./chunk-HSGZW3ID.js";
+import "./chunk-FXDYIV3K.js";
+import "./chunk-66QOCD5N.js";
+import "./chunk-GDS2HXSW.js";
+import "./chunk-IWIIOFEB.js";
+import "./chunk-KBEIQP4G.js";
+import "./chunk-7JDMYTFZ.js";
+import "./chunk-IGKPPACU.js";
+import "./chunk-6MLEBAYZ.js";
+import "./chunk-VT4PDUYT.js";
+export {
+  InitCommand
+};
+//# sourceMappingURL=init-MZBIXQ7V.js.map

package/dist/{lint-HAVU4U34.js → lint-MDVUV3W2.js}

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 import {
   ScriptCommandBase
-} from "./chunk-ELJKYFSH.js";
-import "./chunk-5V74K5ZA.js";
+} from "./chunk-BCQDYAOJ.js";
+import "./chunk-TVH67KEO.js";
 import "./chunk-RD7I2Q2F.js";
-import "./chunk-UDRZY65Y.js";
+import "./chunk-HSGZW3ID.js";
 import "./chunk-XPKN3QWY.js";
-import "./chunk-ZA575VLF.js";
-import "./chunk-WFQ5CLTR.js";
-import "./chunk-VWGKGNJP.js";
+import "./chunk-GDS2HXSW.js";
+import "./chunk-IWIIOFEB.js";
+import "./chunk-KBEIQP4G.js";
 import "./chunk-6MLEBAYZ.js";
 import "./chunk-VT4PDUYT.js";
 
@@ -24,4 +24,4 @@ var LintCommand = class extends ScriptCommandBase {
 export {
   LintCommand
 };
-//# sourceMappingURL=lint-HAVU4U34.js.map
+//# sourceMappingURL=lint-MDVUV3W2.js.map

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,148 @@ 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";
@@ -727,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 {
@@ -1000,6 +1208,157 @@ 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";
@@ -1315,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
@@ -1729,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();