@iloom/cli 0.6.1 → 0.7.0

package/dist/init-XQQMFDM6.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+import {
+  InitCommand
+} from "./chunk-FEAJR6PN.js";
+import "./chunk-Q7POFB5Q.js";
+import "./chunk-F2PWIRV4.js";
+import "./chunk-N7FVXZNI.js";
+import "./chunk-UDRZY65Y.js";
+import "./chunk-FXDYIV3K.js";
+import "./chunk-TIYJEEVO.js";
+import "./chunk-ZA575VLF.js";
+import "./chunk-WFQ5CLTR.js";
+import "./chunk-VWGKGNJP.js";
+import "./chunk-ZX3GTM7O.js";
+import "./chunk-FP7G7DG3.js";
+import "./chunk-6MLEBAYZ.js";
+import "./chunk-VT4PDUYT.js";
+export {
+  InitCommand
+};
+//# sourceMappingURL=init-XQQMFDM6.js.map

package/dist/{lint-5JMCWE4Y.js → lint-OFVN7FT6.js}

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 import {
   ScriptCommandBase
-} from "./chunk-TRQ76ISK.js";
-import "./chunk-AXX3QIKK.js";
-import "./chunk-UQIXZ3BA.js";
-import "./chunk-BXCPJJYM.js";
-import "./chunk-EK3XCAAS.js";
-import "./chunk-GEXP5IOF.js";
-import "./chunk-F6WVM437.js";
-import "./chunk-CFUWQHCJ.js";
+} from "./chunk-Z6BO53V7.js";
+import "./chunk-5V74K5ZA.js";
+import "./chunk-LLWX3PCW.js";
+import "./chunk-UDRZY65Y.js";
+import "./chunk-ITN64ENQ.js";
+import "./chunk-ZA575VLF.js";
+import "./chunk-WFQ5CLTR.js";
+import "./chunk-VWGKGNJP.js";
 import "./chunk-6MLEBAYZ.js";
 import "./chunk-VT4PDUYT.js";
 
@@ -24,4 +24,4 @@ var LintCommand = class extends ScriptCommandBase {
 export {
   LintCommand
 };
-//# sourceMappingURL=lint-5JMCWE4Y.js.map
+//# sourceMappingURL=lint-OFVN7FT6.js.map

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

@@ -129,6 +129,42 @@ async function executeGhCommand(args, options) {
   const data = isJson ? JSON.parse(result.stdout) : result.stdout;
   return data;
 }
+async function createIssue(title, body, options) {
+  const { repo, labels } = options ?? {};
+  logger.debug("Creating GitHub issue", { title, repo, labels });
+  const args = [
+    "issue",
+    "create",
+    "--title",
+    title,
+    "--body",
+    body
+  ];
+  if (repo) {
+    args.splice(2, 0, "--repo", repo);
+  }
+  if (labels && labels.length > 0) {
+    args.push("--label", labels.join(","));
+  }
+  const execaOptions = {
+    timeout: 3e4,
+    encoding: "utf8"
+  };
+  if (!repo) {
+    execaOptions.cwd = process.cwd();
+  }
+  const result = await execa2("gh", args, execaOptions);
+  const urlMatch = result.stdout.trim().match(/https:\/\/github\.com\/[^/]+\/[^/]+\/issues\/(\d+)/);
+  if (!(urlMatch == null ? void 0 : urlMatch[1])) {
+    throw new Error(`Failed to parse issue URL from gh output: ${result.stdout}`);
+  }
+  const issueNumber = parseInt(urlMatch[1], 10);
+  const issueUrl = urlMatch[0];
+  return {
+    number: issueNumber,
+    url: issueUrl
+  };
+}
 async function createIssueComment(issueNumber, body, repo) {
   logger.debug("Creating issue comment", { issueNumber, repo });
   const apiPath = repo ? `repos/${repo}/issues/${issueNumber}/comments` : `repos/:owner/:repo/issues/${issueNumber}/comments`;
@@ -167,6 +203,38 @@ async function createPRComment(prNumber, body, repo) {
     "{id: .id, url: .html_url, created_at: .created_at}"
   ]);
 }
+async function getIssueNodeId(issueNumber, repo) {
+  logger.debug("Fetching GitHub issue node ID", { issueNumber, repo });
+  const args = ["issue", "view", String(issueNumber), "--json", "id"];
+  if (repo) {
+    args.push("--repo", repo);
+  }
+  const result = await executeGhCommand(args);
+  return result.id;
+}
+async function addSubIssue(parentNodeId, childNodeId) {
+  logger.debug("Linking child issue to parent", { parentNodeId, childNodeId });
+  const mutation = `
+		mutation addSubIssue($parentId: ID!, $subIssueId: ID!) {
+			addSubIssue(input: { issueId: $parentId, subIssueId: $subIssueId }) {
+				issue { id }
+				subIssue { id }
+			}
+		}
+	`;
+  await executeGhCommand([
+    "api",
+    "graphql",
+    "-H",
+    "GraphQL-Features: sub_issues",
+    "-f",
+    `query=${mutation}`,
+    "-F",
+    `parentId=${parentNodeId}`,
+    "-F",
+    `subIssueId=${childNodeId}`
+  ]);
+}
 
 // src/mcp/GitHubIssueManagementProvider.ts
 function normalizeAuthor(author) {
@@ -191,25 +259,30 @@ function extractNumericIdFromUrl(url) {
 var GitHubIssueManagementProvider = class {
   constructor() {
     this.providerName = "github";
+    this.issuePrefix = "#";
   }
   /**
    * Fetch issue details using gh CLI
    * Normalizes GitHub-specific fields to provider-agnostic format
    */
   async getIssue(input) {
-    const { number, includeComments = true } = input;
+    const { number, includeComments = true, 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 fields = includeComments ? "body,title,comments,labels,assignees,milestone,author,state,number,url" : "body,title,labels,assignees,milestone,author,state,number,url";
-    const raw = await executeGhCommand([
+    const args = [
       "issue",
       "view",
       String(issueNumber),
       "--json",
       fields
-    ]);
+    ];
+    if (repo) {
+      args.push("--repo", repo);
+    }
+    const raw = await executeGhCommand(args);
     const result = {
       // Core fields
       id: String(raw.number),
@@ -248,14 +321,15 @@ var GitHubIssueManagementProvider = class {
    * Normalizes author to FlexibleAuthor format
    */
   async getComment(input) {
-    const { commentId } = input;
+    const { commentId, repo } = input;
     const numericCommentId = parseInt(commentId, 10);
     if (isNaN(numericCommentId)) {
       throw new Error(`Invalid GitHub comment ID: ${commentId}. GitHub comment IDs must be numeric.`);
     }
+    const apiPath = repo ? `repos/${repo}/issues/comments/${numericCommentId}` : `repos/:owner/:repo/issues/comments/${numericCommentId}`;
     const raw = await executeGhCommand([
       "api",
-      `repos/:owner/:repo/issues/comments/${numericCommentId}`,
+      apiPath,
       "--jq",
       "{id: .id, body: .body, user: .user, created_at: .created_at, updated_at: .updated_at, html_url: .html_url, reactions: .reactions}"
     ]);
@@ -300,6 +374,40 @@ var GitHubIssueManagementProvider = class {
       id: String(result.id)
     };
   }
+  /**
+   * Create a new issue
+   */
+  async createIssue(input) {
+    const { title, body, labels, repo } = input;
+    const result = await createIssue(title, body, { labels, repo });
+    const issueNumber = typeof result.number === "number" ? result.number : parseInt(String(result.number), 10);
+    return {
+      id: String(issueNumber),
+      url: result.url,
+      number: issueNumber
+    };
+  }
+  /**
+   * Create a child issue linked to a parent issue
+   * GitHub requires two-step process: create issue, then link via GraphQL
+   */
+  async createChildIssue(input) {
+    const { parentId, title, body, labels, repo } = input;
+    const parentNumber = parseInt(parentId, 10);
+    if (isNaN(parentNumber)) {
+      throw new Error(`Invalid GitHub parent issue number: ${parentId}. GitHub issue IDs must be numeric.`);
+    }
+    const parentNodeId = await getIssueNodeId(parentNumber, repo);
+    const childResult = await createIssue(title, body, { labels, repo });
+    const childNumber = typeof childResult.number === "number" ? childResult.number : parseInt(String(childResult.number), 10);
+    const childNodeId = await getIssueNodeId(childNumber, repo);
+    await addSubIssue(parentNodeId, childNodeId);
+    return {
+      id: String(childNumber),
+      url: childResult.url,
+      number: childNumber
+    };
+  }
 };
 
 // src/utils/linear.ts
@@ -319,6 +427,30 @@ var LinearServiceError = class _LinearServiceError extends Error {
 };
 
 // src/utils/linear.ts
+function slugifyTitle(title, maxLength = 50) {
+  const slug = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  if (slug.length <= maxLength) {
+    return slug;
+  }
+  const parts = slug.split("-");
+  let result = "";
+  for (const part of parts) {
+    const candidate = result ? `${result}-${part}` : part;
+    if (candidate.length > maxLength) {
+      break;
+    }
+    result = candidate;
+  }
+  return result || slug.slice(0, maxLength);
+}
+function buildLinearIssueUrl(identifier, title) {
+  const base = `https://linear.app/issue/${identifier}`;
+  if (title) {
+    const slug = slugifyTitle(title);
+    return slug ? `${base}/${slug}` : base;
+  }
+  return base;
+}
 function getLinearApiToken() {
   const token = process.env.LINEAR_API_TOKEN;
   if (!token) {
@@ -383,6 +515,74 @@ async function fetchLinearIssue(identifier) {
     handleLinearError(error, "fetchLinearIssue");
   }
 }
+async function createLinearIssue(title, body, teamKey, _labels) {
+  try {
+    logger.debug(`Creating Linear issue in team ${teamKey}: ${title}`);
+    const client = createLinearClient();
+    const teams = await client.teams();
+    const team = teams.nodes.find((t) => t.key === teamKey);
+    if (!team) {
+      throw new LinearServiceError("NOT_FOUND", `Linear team ${teamKey} not found`);
+    }
+    const issueInput = {
+      teamId: team.id,
+      title
+    };
+    if (body) {
+      issueInput.description = body;
+    }
+    const payload = await client.createIssue(issueInput);
+    const issue = await payload.issue;
+    if (!issue) {
+      throw new LinearServiceError("CLI_ERROR", "Failed to create Linear issue");
+    }
+    const url = issue.url ?? buildLinearIssueUrl(issue.identifier, title);
+    return {
+      identifier: issue.identifier,
+      url
+    };
+  } catch (error) {
+    if (error instanceof LinearServiceError) {
+      throw error;
+    }
+    handleLinearError(error, "createLinearIssue");
+  }
+}
+async function createLinearChildIssue(title, body, teamKey, parentId, _labels) {
+  try {
+    logger.debug(`Creating Linear child issue in team ${teamKey}: ${title}`);
+    const client = createLinearClient();
+    const teams = await client.teams();
+    const team = teams.nodes.find((t) => t.key === teamKey);
+    if (!team) {
+      throw new LinearServiceError("NOT_FOUND", `Linear team ${teamKey} not found`);
+    }
+    const issueInput = {
+      teamId: team.id,
+      title,
+      parentId
+      // UUID of parent issue
+    };
+    if (body) {
+      issueInput.description = body;
+    }
+    const payload = await client.createIssue(issueInput);
+    const issue = await payload.issue;
+    if (!issue) {
+      throw new LinearServiceError("CLI_ERROR", "Failed to create Linear child issue");
+    }
+    const url = issue.url ?? buildLinearIssueUrl(issue.identifier, title);
+    return {
+      identifier: issue.identifier,
+      url
+    };
+  } catch (error) {
+    if (error instanceof LinearServiceError) {
+      throw error;
+    }
+    handleLinearError(error, "createLinearChildIssue");
+  }
+}
 async function createLinearComment(identifier, body) {
   try {
     logger.debug(`Creating comment on Linear issue ${identifier}`);
@@ -640,12 +840,22 @@ ${content}
 var LinearIssueManagementProvider = class {
   constructor() {
     this.providerName = "linear";
+    this.issuePrefix = "";
+    /**
+     * Cached team key extracted from issue identifiers (e.g., "ENG-123" -> "ENG")
+     * Used as fallback when teamKey is not explicitly provided to createIssue()
+     */
+    this.cachedTeamKey = void 0;
   }
   /**
    * Fetch issue details using Linear SDK
    */
   async getIssue(input) {
     const { number, includeComments = true } = input;
+    const match = number.match(/^([A-Z]{2,})-\d+$/i);
+    if (match == null ? void 0 : match[1]) {
+      this.cachedTeamKey = match[1].toUpperCase();
+    }
     const raw = await fetchLinearIssue(number);
     const state = raw.state && (raw.state.toLowerCase().includes("done") || raw.state.toLowerCase().includes("completed") || raw.state.toLowerCase().includes("canceled")) ? "closed" : "open";
     const result = {
@@ -731,6 +941,47 @@ var LinearIssueManagementProvider = class {
       updated_at: result.updatedAt
     };
   }
+  /**
+   * Create a new issue
+   */
+  async createIssue(input) {
+    const { title, body, labels, teamKey } = input;
+    const effectiveTeamKey = teamKey ?? process.env.LINEAR_TEAM_KEY ?? this.cachedTeamKey;
+    if (!effectiveTeamKey) {
+      throw new Error("teamKey is required for Linear issue creation. Configure issueManagement.linear.teamId in settings, or call getIssue first to extract the team from an issue identifier.");
+    }
+    const result = await createLinearIssue(title, body, effectiveTeamKey, labels);
+    return {
+      id: result.identifier,
+      url: result.url
+    };
+  }
+  /**
+   * Create a child issue linked to a parent issue
+   * Linear supports atomic creation with parentId field
+   */
+  async createChildIssue(input) {
+    var _a;
+    const { parentId, title, body, labels, teamKey } = input;
+    const parentIssue = await fetchLinearIssue(parentId);
+    const match = parentId.match(/^([A-Z]{2,})-\d+$/i);
+    const effectiveTeamKey = teamKey ?? ((_a = match == null ? void 0 : match[1]) == null ? void 0 : _a.toUpperCase()) ?? process.env.LINEAR_TEAM_KEY ?? this.cachedTeamKey;
+    if (!effectiveTeamKey) {
+      throw new Error("teamKey is required for Linear child issue creation. Provide teamKey parameter or use a parent identifier with team prefix.");
+    }
+    const result = await createLinearChildIssue(
+      title,
+      body,
+      effectiveTeamKey,
+      parentIssue.id,
+      // UUID, not identifier
+      labels
+    );
+    return {
+      id: result.identifier,
+      url: result.url
+    };
+  }
 };
 
 // src/mcp/IssueManagementProviderFactory.ts
@@ -794,7 +1045,10 @@ server.registerTool(
     description: "Fetch issue details including body, title, comments, labels, assignees, and other metadata. Author fields vary by provider: GitHub uses { login }, Linear uses { name, displayName }, Jira uses { displayName, accountId }. All authors have normalized core fields: { id, displayName } plus provider-specific fields.",
     inputSchema: {
       number: z.string().describe("The issue identifier"),
-      includeComments: z.boolean().optional().describe("Whether to include comments (default: true)")
+      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. GitHub only.'
+      )
     },
     outputSchema: {
       // Core validated fields
@@ -826,13 +1080,13 @@ server.registerTool(
       ).optional().describe("Issue comments with flexible author structure")
     }
   },
-  async ({ number, includeComments }) => {
-    console.error(`Fetching issue ${number}`);
+  async ({ number, includeComments, repo }) => {
+    console.error(`Fetching issue ${number}${repo ? ` from ${repo}` : ""}`);
     try {
       const provider = IssueManagementProviderFactory.create(
         process.env.ISSUE_PROVIDER
       );
-      const result = await provider.getIssue({ number, includeComments });
+      const result = await provider.getIssue({ number, includeComments, repo });
       console.error(`Issue fetched successfully: ${result.number} - ${result.title}`);
       return {
         content: [
@@ -857,7 +1111,10 @@ server.registerTool(
     description: "Fetch a specific comment by ID. Author has normalized core fields { id, displayName } plus provider-specific fields.",
     inputSchema: {
       commentId: z.string().describe("The comment identifier to fetch"),
-      number: z.string().describe("The issue or PR identifier (context for providers that need it)")
+      number: z.string().describe("The issue or PR identifier (context for providers that need it)"),
+      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: {
       id: z.string().describe("Comment identifier"),
@@ -869,13 +1126,13 @@ server.registerTool(
       updated_at: z.string().optional().describe("Comment last updated timestamp")
     }
   },
-  async ({ commentId, number }) => {
-    console.error(`Fetching comment ${commentId} from issue ${number}`);
+  async ({ commentId, number, repo }) => {
+    console.error(`Fetching comment ${commentId} from issue ${number}${repo ? ` in ${repo}` : ""}`);
     try {
       const provider = IssueManagementProviderFactory.create(
         process.env.ISSUE_PROVIDER
       );
-      const result = await provider.getComment({ commentId, number });
+      const result = await provider.getComment({ commentId, number, repo });
       console.error(`Comment fetched successfully: ${result.id}`);
       return {
         content: [
@@ -977,6 +1234,95 @@ server.registerTool(
     }
   }
 );
+server.registerTool(
+  "create_issue",
+  {
+    title: "Create Issue",
+    description: 'Create a new issue in the configured issue tracker. For GitHub: creates issue in the configured repository. For Linear: requires teamKey parameter (e.g., "ENG", "PLAT"), or configure issueManagement.linear.teamId in settings, or call get_issue first to auto-detect the team.',
+    inputSchema: {
+      title: z.string().describe("The issue title"),
+      body: z.string().describe("The issue body/description (markdown supported)"),
+      labels: z.array(z.string()).optional().describe("Optional labels to apply to the issue"),
+      teamKey: z.string().optional().describe('Team key for Linear (e.g., "ENG"). Falls back to settings or team extracted from previous get_issue call. Ignored for GitHub.'),
+      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: {
+      id: z.string().describe("Issue identifier"),
+      url: z.string().describe("Issue URL"),
+      number: z.number().optional().describe("Issue number (GitHub only)")
+    }
+  },
+  async ({ title, body, labels, teamKey, repo }) => {
+    console.error(`Creating issue: ${title}${repo ? ` in ${repo}` : ""}`);
+    try {
+      const provider = IssueManagementProviderFactory.create(
+        process.env.ISSUE_PROVIDER
+      );
+      const result = await provider.createIssue({ title, body, labels, teamKey, repo });
+      console.error(`Issue created successfully: ${result.id} at ${result.url}`);
+      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 create issue: ${errorMessage}`);
+      throw new Error(`Failed to create issue: ${errorMessage}`);
+    }
+  }
+);
+server.registerTool(
+  "create_child_issue",
+  {
+    title: "Create Child Issue",
+    description: 'Create a new child issue linked to a parent issue. For GitHub: creates issue and links via sub-issue API (requires two API calls). For Linear: creates issue atomically with parent relationship. The parentId should be the parent issue identifier (GitHub issue number or Linear identifier like "ENG-123").',
+    inputSchema: {
+      parentId: z.string().describe('Parent issue identifier (GitHub issue number or Linear identifier like "ENG-123")'),
+      title: z.string().describe("The child issue title"),
+      body: z.string().describe("The child issue body/description (markdown supported)"),
+      labels: z.array(z.string()).optional().describe("Optional labels to apply to the child issue"),
+      teamKey: z.string().optional().describe('Team key for Linear (e.g., "ENG"). Falls back to parent team. Ignored for GitHub.'),
+      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: {
+      id: z.string().describe("Issue identifier"),
+      url: z.string().describe("Issue URL"),
+      number: z.number().optional().describe("Issue number (GitHub only)")
+    }
+  },
+  async ({ parentId, title, body, labels, teamKey, repo }) => {
+    console.error(`Creating child issue for parent ${parentId}: ${title}${repo ? ` in ${repo}` : ""}`);
+    try {
+      const provider = IssueManagementProviderFactory.create(
+        process.env.ISSUE_PROVIDER
+      );
+      const result = await provider.createChildIssue({ parentId, title, body, labels, teamKey, repo });
+      console.error(`Child issue created successfully: ${result.id} at ${result.url}`);
+      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 create child issue: ${errorMessage}`);
+      throw new Error(`Failed to create child issue: ${errorMessage}`);
+    }
+  }
+);
 async function main() {
   console.error("Starting Issue Management MCP Server...");
   const provider = validateEnvironment();