createComment

Instructions

Implementation Reference

• src/tools/comments/createComment.ts:66-96 (handler)

  The handler function `handleCreateComment` that executes the createComment tool logic. It extracts input fields (resource, resourceId, body, notify, isPrivate, pendingFileAttachments, contentType, authorId), builds commentData, and calls the service layer.

  export async function handleCreateComment(input: any) {
    logger.info('Calling teamworkService.createComment()');
    logger.info(`Resource: ${input?.resource}, Resource ID: ${input?.resourceId}`);
    
    try {
      const resource = input.resource;
      const resourceId = input.resourceId;
      const commentData: any = {};
      
      // Set required fields
      commentData.body = input.body;
      
      // Set optional fields if provided
      if (input.notify !== undefined) commentData.notify = input.notify;
      if (input.isPrivate !== undefined) commentData['isprivate'] = input.isPrivate;
      if (input.pendingFileAttachments) commentData.pendingFileAttachments = input.pendingFileAttachments;
      if (input.contentType === 'html') commentData['content-type'] = 'html';
      if (input.authorId) commentData['author-id'] = input.authorId;
      
      const result = await teamworkService.createComment(resource, resourceId, commentData);
      
      return {
        content: [{
          type: "text",
          text: JSON.stringify(result, null, 2)
        }]
      };
    } catch (error: any) {
      return createErrorResponse(error, 'Creating comment');
    }
  } 

• src/tools/comments/createComment.ts:11-63 (schema)

  The tool definition `createCommentDefinition` containing the name, description, inputSchema (with fields: resource, resourceId, body, notify, isPrivate, pendingFileAttachments, contentType, authorId), and annotations.

  export const createCommentDefinition = {
    name: "createComment",
    description: "Creates a new comment for a specific resource (tasks, milestones, notebooks, links, fileversions) in Teamwork",
    inputSchema: {
      type: "object",
      properties: {
        resource: {
          type: "string",
          description: "The resource type (tasks, milestones, notebooks, links, fileversions)",
          enum: ["tasks", "milestones", "notebooks", "links", "fileversions"]
        },
        resourceId: {
          type: "string",
          description: "The ID of the resource to add a comment to"
        },
        body: {
          type: "string",
          description: "The content of the comment"
        },
        notify: {
          type: "string",
          description: "Who to notify ('all' to notify all project users, 'true' to notify followers, specific user IDs, or empty for no notification)",
          default: ""
        },
        isPrivate: {
          type: "boolean",
          description: "Whether the comment should be private",
          default: false
        },
        pendingFileAttachments: {
          type: "string",
          description: "Comma-separated list of pending file references to attach to the comment"
        },
        contentType: {
          type: "string",
          description: "Content type of the comment (html or plain text)",
          enum: ["html", "plaintext"],
          default: "plaintext"
        },
        authorId: {
          type: "string",
          description: "ID of the user to post as (only for admins)"
        }
      },
      required: ["resource", "resourceId", "body"]
    },
    annotations: {
      title: "Create Comment",
      readOnlyHint: false,
      destructiveHint: false,
      openWorldHint: false
    }
  };

• src/services/comments/createComment.ts:11-35 (helper)

  The service layer function `createComment` that performs the actual API call to Teamwork's v1 endpoint POST /{resource}/{resourceId}/comments.json with the comment payload.

  export const createComment = async (resource: string, resourceId: string, commentData: any) => {
    try {
      // Validate resource type
      const validResources = ['tasks', 'milestones', 'notebooks', 'links', 'fileversions'];
      if (!validResources.includes(resource)) {
        throw new Error(`Invalid resource type. Must be one of: ${validResources.join(', ')}`);
      }
      
      // For API v1, we need the proper client
      const api = getApiClientForVersion('v1');
      
      // We're using the v1 API which has a different format for the request
      const payload = {
        comment: commentData
      };
      
      // The API v1 endpoint doesn't include the base path
      const response = await api.post(`/${resource}/${resourceId}/comments.json`, payload);
      
      return response.data;
    } catch (error: any) {
      logger.error(`Error creating comment for ${resource}/${resourceId}: ${error.message}`);
      throw new Error(`Failed to create comment for ${resource}/${resourceId}: ${error.message}`);
    }
  };

• src/tools/index.ts:27-27 (registration)

  Import of createCommentDefinition (aliased as createComment) and handleCreateComment from the tool file into the tools index.

  import { createCommentDefinition as createComment, handleCreateComment } from './comments/createComment.js';

• src/tools/index.ts:82-82 (registration)

  Registration of the createComment tool pair (definition + handler) in the toolPairs array for the MCP server.

  { definition: createComment, handler: handleCreateComment },