addPeopleToProject

Instructions

Implementation Reference

• src/tools/people/addPeopleToProject.ts:47-121 (handler)

  The tool handler function that executes the 'addPeopleToProject' tool logic. Validates inputs (projectId, userIds), constructs the payload, calls the service layer, and returns the response.

  export async function handleAddPeopleToProject(input: any) {
    logger.info('=== addPeopleToProject tool called ===');
    logger.info(`Input parameters: ${JSON.stringify(input || {})}`);
    
    try {
      if (!input.projectId) {
        logger.error('Missing required parameter: projectId');
        return {
          content: [{
            type: "text",
            text: "Error: Missing required parameter 'projectId'"
          }]
        };
      }
      
      if (!input.userIds || !Array.isArray(input.userIds) || input.userIds.length === 0) {
        logger.error('Missing or invalid required parameter: userIds');
        return {
          content: [{
            type: "text",
            text: "Error: Missing or invalid required parameter 'userIds'. Must be a non-empty array of user IDs."
          }]
        };
      }
      
      const projectId = parseInt(input.projectId, 10);
      if (isNaN(projectId)) {
        logger.error(`Invalid projectId: ${input.projectId}`);
        return {
          content: [{
            type: "text",
            text: `Error: Invalid projectId. Must be a number.`
          }]
        };
      }
      
      // Prepare the payload with proper typing
      const payload: AddPeopleToProjectPayload = {
        userIds: input.userIds
      };
      
      // Add checkTeamIds if provided
      if (input.checkTeamIds && Array.isArray(input.checkTeamIds)) {
        payload.checkTeamIds = input.checkTeamIds;
      }
      
      logger.info(`Calling teamworkService.addPeopleToProject(${projectId}, ${JSON.stringify(payload)})`);
      const result = await teamworkService.addPeopleToProject(projectId, payload);
      
      // Debug the response
      logger.info(`Add people to project response type: ${typeof result}`);
      
      try {
        const jsonString = JSON.stringify(result, null, 2);
        logger.info(`Successfully stringified response`);
        logger.info('=== addPeopleToProject tool completed successfully ===');
        return {
          content: [{
            type: "text",
            text: jsonString
          }]
        };
      } catch (jsonError: any) {
        logger.error(`JSON stringify error: ${jsonError.message}`);
        return {
          content: [{
            type: "text",
            text: `Error formatting response: ${jsonError.message}`
          }]
        };
      }
    } catch (error: any) {
      return createErrorResponse(error, 'Adding people to project');
    }
  } 

• src/tools/people/addPeopleToProject.ts:11-44 (schema)

  Tool definition including inputSchema for 'addPeopleToProject' with required fields: projectId (integer), userIds (array of integers), and optional checkTeamIds (array of integers).

  export const addPeopleToProjectDefinition = {
    name: "addPeopleToProject",
    description: "Add people to a specific project in Teamwork",
    inputSchema: {
      type: "object",
      properties: {
        projectId: {
          type: "integer",
          description: "The ID of the project to add people to"
        },
        userIds: {
          type: "array",
          items: {
            type: "integer"
          },
          description: "Array of user IDs to add to the project"
        },
        checkTeamIds: {
          type: "array",
          items: {
            type: "integer"
          },
          description: "Optional array of team IDs to check"
        }
      },
      required: ["projectId", "userIds"]
    },
    annotations: {
      title: "Add People to Project",
      readOnlyHint: false,
      destructiveHint: false,
      openWorldHint: false
    }
  };

• src/services/people/addPeopleToProject.ts:7-10 (schema)

  TypeScript interface AddPeopleToProjectPayload defining the service-layer payload shape: userIds (number[]) and optional checkTeamIds (number[]).

  export interface AddPeopleToProjectPayload {
    userIds: number[];
    checkTeamIds?: number[];
  }

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

  Import and registration of the addPeopleToProject tool definition and handler in the central tools index. The tool is added to the toolPairs array at line 86, which feeds into toolDefinitions and toolHandlersMap.

  import { addPeopleToProjectDefinition as addPeopleToProject, handleAddPeopleToProject } from './people/addPeopleToProject.js';
  import { deletePersonDefinition as deletePerson, handleDeletePerson } from './people/deletePerson.js';
  import { updatePersonDefinition as updatePerson, handleUpdatePerson } from './people/updatePerson.js';
  
  // Companies
  import { createCompanyDefinition as createCompany, handleCreateCompany } from './companies/createCompany.js';
  import { updateCompanyDefinition as updateCompany, handleUpdateCompany } from './companies/updateCompany.js';
  import { deleteCompanyDefinition as deleteCompany, handleDeleteCompany } from './companies/deleteCompany.js';
  import { getCompaniesDefinition as getCompanies, handleGetCompanies } from './companies/getCompanies.js';
  import { getCompanyByIdDefinition as getCompanyById, handleGetCompanyById } from './companies/getCompanyById.js';
  
  // Reporting
  import { getProjectsPeopleMetricsPerformanceDefinition as getProjectsPeopleMetricsPerformance, handleGetProjectsPeopleMetricsPerformance } from './people/getPeopleMetricsPerformance.js';
  import { getProjectsPeopleUtilizationDefinition as getProjectsPeopleUtilization, handleGetProjectsPeopleUtilization } from './people/getPeopleUtilization.js';
  import { getProjectPersonDefinition as getProjectPerson, handleGetProjectPerson } from './people/getProjectPerson.js';
  import { getProjectsReportingUserTaskCompletionDefinition as getProjectsReportingUserTaskCompletion, handleGetProjectsReportingUserTaskCompletion } from './reporting/getUserTaskCompletion.js';
  import { getProjectsReportingUtilizationDefinition as getProjectsReportingUtilization, handleGetProjectsReportingUtilization } from './people/getUtilization.js';
  
  // Time-related imports
  import { getTimeDefinition as getTime, handleGetTime } from './time/getTime.js';
  import { getProjectsAllocationsTimeDefinition as getAllocationTime, handleGetProjectsAllocationsTime } from './time/getAllocationTime.js';
  
  // Core
  import { getTimezonesDefinition as getTimezones, handleGetTimezones } from './core/getTimezones.js';
  
  // Define a structure that pairs tool definitions with their handlers
  interface ToolPair {
    definition: any;
    handler: Function;
  }
  
  // Create an array of tool pairs
  const toolPairs: ToolPair[] = [
    { definition: getProjects, handler: handleGetProjects },
    { definition: getCurrentProject, handler: handleGetCurrentProject },
    { definition: createProject, handler: handleCreateProject },
    { definition: getTasks, handler: handleGetTasks },
    { definition: getTasksByProjectId, handler: handleGetTasksByProjectId },
    { definition: getTaskListsByProjectId, handler: handleGetTaskListsByProjectId },
    { definition: getTasksByTaskListId, handler: handleGetTasksByTaskListId },
    { definition: getTaskById, handler: handleGetTaskById },
    { definition: createTask, handler: handleCreateTask },
    { definition: createSubTask, handler: handleCreateSubTask },
    { definition: updateTask, handler: handleUpdateTask },
    { definition: deleteTask, handler: handleDeleteTask },
    { definition: getTasksMetricsComplete, handler: handleGetTasksMetricsComplete },
    { definition: getTasksMetricsLate, handler: handleGetTasksMetricsLate },
    { definition: getTaskSubtasks, handler: handleGetTaskSubtasks },
    { definition: getTaskComments, handler: handleGetTaskComments },
    { definition: createComment, handler: handleCreateComment },
    { definition: getPeople, handler: handleGetPeople },
    { definition: getPersonById, handler: handleGetPersonById },
    { definition: getProjectPeople, handler: handleGetProjectPeople },
    { definition: addPeopleToProject, handler: handleAddPeopleToProject },

• src/services/people/addPeopleToProject.ts:18-31 (helper)

  Service-layer function that calls the Teamwork API (PUT /projects/{projectId}/people.json) to add people to a project. This is the underlying API call helper.

  export const addPeopleToProject = async (projectId: number, payload: AddPeopleToProjectPayload) => {
    try {
      logger.info(`Adding people to project ID ${projectId} in Teamwork API`);
      logger.info(`Payload: ${JSON.stringify(payload)}`);
      
      const api = ensureApiClient();
      const response = await api.put(`/projects/${projectId}/people.json`, payload);
      logger.info(`Successfully added people to project ID ${projectId}`);
      return response.data;
    } catch (error: any) {
      logger.error(`Teamwork API error: ${error.message}`);
      throw new Error(`Failed to add people to project ID ${projectId} in Teamwork API`);
    }
  };