feat(mcp): add linear comment CRUD tools (STA-493)

StackMemory Bot (CLI) · StackMemory Bot (CLI) · commit 0fe96ec9e541 · 2026-03-20T15:16:10.000-04:00
Add 3 MCP tools for Linear comment management:
- linear_create_comment: create comment on issue (workpad init)
- linear_update_comment: edit existing comment by ID (workpad update)
- linear_list_comments: list comments on issue (find workpad)

Also adds createComment/updateComment/getComments to LinearClient.
diff --git a/src/integrations/linear/client.ts b/src/integrations/linear/client.ts
@@ -895,4 +895,123 @@ export class LinearClient {
       };
     }
   }
+
+  // --- Comment CRUD ---
+
+  async createComment(
+    issueId: string,
+    body: string
+  ): Promise<{ id: string; body: string; createdAt: string }> {
+    const mutation = `
+      mutation CreateComment($input: CommentCreateInput!) {
+        commentCreate(input: $input) {
+          success
+          comment {
+            id
+            body
+            createdAt
+            user { id name }
+          }
+        }
+      }
+    `;
+
+    const result = await this.graphql<{
+      commentCreate: {
+        success: boolean;
+        comment: {
+          id: string;
+          body: string;
+          createdAt: string;
+          user: { id: string; name: string };
+        };
+      };
+    }>(mutation, { input: { issueId, body } });
+
+    if (!result.commentCreate.success) {
+      throw new IntegrationError(
+        'Failed to create comment',
+        ErrorCode.LINEAR_API_ERROR,
+        { issueId }
+      );
+    }
+
+    return result.commentCreate.comment;
+  }
+
+  async updateComment(
+    commentId: string,
+    body: string
+  ): Promise<{ id: string; body: string; updatedAt: string }> {
+    const mutation = `
+      mutation UpdateComment($id: String!, $input: CommentUpdateInput!) {
+        commentUpdate(id: $id, input: $input) {
+          success
+          comment {
+            id
+            body
+            updatedAt
+          }
+        }
+      }
+    `;
+
+    const result = await this.graphql<{
+      commentUpdate: {
+        success: boolean;
+        comment: { id: string; body: string; updatedAt: string };
+      };
+    }>(mutation, { id: commentId, input: { body } });
+
+    if (!result.commentUpdate.success) {
+      throw new IntegrationError(
+        'Failed to update comment',
+        ErrorCode.LINEAR_API_ERROR,
+        { commentId }
+      );
+    }
+
+    return result.commentUpdate.comment;
+  }
+
+  async getComments(
+    issueId: string
+  ): Promise<
+    Array<{
+      id: string;
+      body: string;
+      createdAt: string;
+      user: { name: string } | null;
+    }>
+  > {
+    const query = `
+      query GetComments($issueId: String!) {
+        issue(id: $issueId) {
+          comments(first: 100) {
+            nodes {
+              id
+              body
+              createdAt
+              user { name }
+            }
+          }
+        }
+      }
+    `;
+
+    const result = await this.graphql<{
+      issue: {
+        comments: {
+          nodes: Array<{
+            id: string;
+            body: string;
+            createdAt: string;
+            user: { name: string } | null;
+          }>;
+        };
+      };
+    }>(query, { issueId });
+
+    return result.issue.comments.nodes;
+  }
 }
diff --git a/src/integrations/mcp/handlers/linear-handlers.ts b/src/integrations/mcp/handlers/linear-handlers.ts
@@ -265,4 +265,117 @@ export class LinearHandlers {
       };
     }
   }
+
+  /**
+   * Create a comment on a Linear issue
+   */
+  async handleLinearCreateComment(args: any): Promise<any> {
+    try {
+      const { issue_id, body } = args;
+      if (!issue_id || !body) {
+        throw new Error('issue_id and body are required');
+      }
+
+      const client = await this.getClient();
+      const comment = await client.createComment(issue_id, body);
+
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `Comment created on ${issue_id}\nID: ${comment.id}\nPreview: ${body.slice(0, 100)}${body.length > 100 ? '...' : ''}`,
+          },
+        ],
+        metadata: {
+          id: comment.id,
+          issueId: issue_id,
+          createdAt: comment.createdAt,
+        },
+      };
+    } catch (error: unknown) {
+      logger.error(
+        'Error creating Linear comment',
+        error instanceof Error ? error : new Error(String(error))
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Update an existing comment on a Linear issue
+   */
+  async handleLinearUpdateComment(args: any): Promise<any> {
+    try {
+      const { comment_id, body } = args;
+      if (!comment_id || !body) {
+        throw new Error('comment_id and body are required');
+      }
+
+      const client = await this.getClient();
+      const comment = await client.updateComment(comment_id, body);
+
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `Comment ${comment_id} updated\nPreview: ${body.slice(0, 100)}${body.length > 100 ? '...' : ''}`,
+          },
+        ],
+        metadata: {
+          id: comment.id,
+          updatedAt: comment.updatedAt,
+        },
+      };
+    } catch (error: unknown) {
+      logger.error(
+        'Error updating Linear comment',
+        error instanceof Error ? error : new Error(String(error))
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * List comments on a Linear issue
+   */
+  async handleLinearListComments(args: any): Promise<any> {
+    try {
+      const { issue_id } = args;
+      if (!issue_id) {
+        throw new Error('issue_id is required');
+      }
+
+      const client = await this.getClient();
+      const comments = await client.getComments(issue_id);
+
+      const lines = comments.map(
+        (c) =>
+          `${c.id.slice(0, 8)} | ${c.user?.name ?? 'unknown'} | ${new Date(c.createdAt).toISOString().slice(0, 10)} | ${c.body.slice(0, 60).replace(/\n/g, ' ')}${c.body.length > 60 ? '...' : ''}`
+      );
+
+      const text =
+        comments.length > 0
+          ? `${comments.length} comments on ${issue_id}:\n${lines.join('\n')}`
+          : `No comments on ${issue_id}`;
+
+      return {
+        content: [{ type: 'text', text }],
+        metadata: {
+          count: comments.length,
+          comments: comments.map((c) => ({
+            id: c.id,
+            author: c.user?.name,
+            createdAt: c.createdAt,
+            bodyPreview: c.body.slice(0, 200),
+          })),
+        },
+      };
+    } catch (error: unknown) {
+      logger.error(
+        'Error listing Linear comments',
+        error instanceof Error ? error : new Error(String(error))
+      );
+      throw error;
+    }
+  }
 }
diff --git a/src/integrations/mcp/server.ts b/src/integrations/mcp/server.ts
@@ -1521,6 +1521,18 @@ class LocalStackMemoryMCP {
               result = await this.handleLinearStatus(args);
               break;
 
+            case 'linear_create_comment':
+              result = await this.handleLinearCreateComment(args);
+              break;
+
+            case 'linear_update_comment':
+              result = await this.handleLinearUpdateComment(args);
+              break;
+
+            case 'linear_list_comments':
+              result = await this.handleLinearListComments(args);
+              break;
+
             case 'get_traces':
               result = await this.handleGetTraces(args);
               break;
@@ -3071,6 +3083,118 @@ class LocalStackMemoryMCP {
     }
   }
 
+  private async getLinearClient() {
+    const { LinearClient } = await import('../linear/client.js');
+    const tokens = this.linearAuthManager.loadTokens();
+    if (!tokens) {
+      throw new Error('Linear not configured. Run: stackmemory linear setup');
+    }
+    return new LinearClient({
+      apiKey: tokens.accessToken,
+      useBearer: true,
+      onUnauthorized: async () => {
+        const refreshed = await this.linearAuthManager.refreshAccessToken();
+        return refreshed.accessToken;
+      },
+    });
+  }
+
+  private async handleLinearCreateComment(args: any) {
+    const { issue_id, body } = args;
+    if (!issue_id || !body) {
+      return {
+        content: [
+          { type: 'text', text: 'Error: issue_id and body are required' },
+        ],
+      };
+    }
+    try {
+      const client = await this.getLinearClient();
+      const comment = await client.createComment(issue_id, body);
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `Comment created on ${issue_id}\nID: ${comment.id}\nPreview: ${body.slice(0, 100)}${body.length > 100 ? '...' : ''}`,
+          },
+        ],
+        metadata: { id: comment.id, issueId: issue_id },
+      };
+    } catch (error: unknown) {
+      const msg = error instanceof Error ? error.message : String(error);
+      return {
+        content: [{ type: 'text', text: `Error creating comment: ${msg}` }],
+      };
+    }
+  }
+
+  private async handleLinearUpdateComment(args: any) {
+    const { comment_id, body } = args;
+    if (!comment_id || !body) {
+      return {
+        content: [
+          { type: 'text', text: 'Error: comment_id and body are required' },
+        ],
+      };
+    }
+    try {
+      const client = await this.getLinearClient();
+      const comment = await client.updateComment(comment_id, body);
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `Comment ${comment_id} updated\nPreview: ${body.slice(0, 100)}${body.length > 100 ? '...' : ''}`,
+          },
+        ],
+        metadata: { id: comment.id, updatedAt: comment.updatedAt },
+      };
+    } catch (error: unknown) {
+      const msg = error instanceof Error ? error.message : String(error);
+      return {
+        content: [{ type: 'text', text: `Error updating comment: ${msg}` }],
+      };
+    }
+  }
+
+  private async handleLinearListComments(args: any) {
+    const { issue_id } = args;
+    if (!issue_id) {
+      return {
+        content: [{ type: 'text', text: 'Error: issue_id is required' }],
+      };
+    }
+    try {
+      const client = await this.getLinearClient();
+      const comments = await client.getComments(issue_id);
+      const lines = comments.map(
+        (c) =>
+          `${c.id.slice(0, 8)} | ${c.user?.name ?? 'unknown'} | ${new Date(c.createdAt).toISOString().slice(0, 10)} | ${c.body.slice(0, 60).replace(/\n/g, ' ')}${c.body.length > 60 ? '...' : ''}`
+      );
+      const text =
+        comments.length > 0
+          ? `${comments.length} comments on ${issue_id}:\n${lines.join('\n')}`
+          : `No comments on ${issue_id}`;
+      return {
+        content: [{ type: 'text', text }],
+        metadata: {
+          count: comments.length,
+          comments: comments.map((c) => ({
+            id: c.id,
+            author: c.user?.name,
+            createdAt: c.createdAt,
+            bodyPreview: c.body.slice(0, 200),
+          })),
+        },
+      };
+    } catch (error: unknown) {
+      const msg = error instanceof Error ? error.message : String(error);
+      return {
+        content: [{ type: 'text', text: `Error listing comments: ${msg}` }],
+      };
+    }
+  }
+
   private async handleGetTraces(args: any) {
     const { type, minScore, limit = 20 } = args;
 
diff --git a/src/integrations/mcp/tool-definitions.ts b/src/integrations/mcp/tool-definitions.ts
