feat: implement get_project_details core functionality

Implements handler for detailed project information including process, work item types, and teams.

Closes #101

Author: openhands-agent

project-management/task-management/doing.md

@@ -1,3 +1,22 @@
 ## Current Task
 
-No task is currently in progress. Please take the next task from todo.md.
+**Task**: Implement get_project_details core functionality (GitHub Issue #101)
+**Phase**: Completion
+
+### Description
+Implement a handler for the `get_project_details` functionality, which will fetch comprehensive information about a specific Azure DevOps project, including metadata, process information, work item types, fields, and team information.
+
+### Notes
+- Need to create the following files:
+  - `src/features/projects/get-project-details/feature.ts` - Core implementation
+  - `src/features/projects/get-project-details/schema.ts` - Request/response schema
+  - `src/features/projects/get-project-details/index.ts` - Export
+- The handler should be registered in `src/server.ts` with the name `mcp_azuredevops_get_project_details`
+- Need to implement tests for the feature
+
+### Sub-tasks
+- [x] Create schema for get_project_details
+- [x] Create tests for get_project_details
+- [x] Implement get_project_details feature
+- [x] Register the handler in server.ts
+- [x] Update exports in projects/index.ts

src/features/projects/get-project-details/feature.spec.int.ts

@@ -0,0 +1,206 @@
+import { WebApi } from 'azure-devops-node-api';
+import { getProjectDetails } from './feature';
+import {
+  getTestConnection,
+  shouldSkipIntegrationTest,
+} from '@/shared/test/test-helpers';
+
+describe('getProjectDetails integration', () => {
+  let connection: WebApi | null = null;
+  let projectName: string;
+
+  beforeAll(async () => {
+    // Get a real connection using environment variables
+    connection = await getTestConnection();
+    projectName = process.env.AZURE_DEVOPS_DEFAULT_PROJECT || 'DefaultProject';
+  });
+
+  test('should retrieve basic project details from Azure DevOps', async () => {
+    // Skip if no connection is available
+    if (shouldSkipIntegrationTest()) {
+      return;
+    }
+
+    // This connection must be available if we didn't skip
+    if (!connection) {
+      throw new Error(
+        'Connection should be available when test is not skipped',
+      );
+    }
+
+    // Act - make an actual API call to Azure DevOps
+    const result = await getProjectDetails(connection, {
+      projectId: projectName,
+    });
+
+    // Assert on the actual response
+    expect(result).toBeDefined();
+    expect(result.name).toBe(projectName);
+    expect(result.id).toBeDefined();
+    expect(result.url).toBeDefined();
+    expect(result.state).toBeDefined();
+
+    // Verify basic project structure
+    expect(result.visibility).toBeDefined();
+    expect(result.lastUpdateTime).toBeDefined();
+    expect(result.capabilities).toBeDefined();
+  });
+
+  test('should retrieve project details with teams from Azure DevOps', async () => {
+    // Skip if no connection is available
+    if (shouldSkipIntegrationTest()) {
+      return;
+    }
+
+    // This connection must be available if we didn't skip
+    if (!connection) {
+      throw new Error(
+        'Connection should be available when test is not skipped',
+      );
+    }
+
+    // Act - make an actual API call to Azure DevOps
+    const result = await getProjectDetails(connection, {
+      projectId: projectName,
+      includeTeams: true,
+    });
+
+    // Assert on the actual response
+    expect(result).toBeDefined();
+    expect(result.teams).toBeDefined();
+    expect(Array.isArray(result.teams)).toBe(true);
+    
+    // There should be at least one team (the default team)
+    if (result.teams && result.teams.length > 0) {
+      const team = result.teams[0];
+      expect(team.id).toBeDefined();
+      expect(team.name).toBeDefined();
+      expect(team.url).toBeDefined();
+    }
+  });
+
+  test('should retrieve project details with process information from Azure DevOps', async () => {
+    // Skip if no connection is available
+    if (shouldSkipIntegrationTest()) {
+      return;
+    }
+
+    // This connection must be available if we didn't skip
+    if (!connection) {
+      throw new Error(
+        'Connection should be available when test is not skipped',
+      );
+    }
+
+    // Act - make an actual API call to Azure DevOps
+    const result = await getProjectDetails(connection, {
+      projectId: projectName,
+      includeProcess: true,
+    });
+
+    // Assert on the actual response
+    expect(result).toBeDefined();
+    expect(result.process).toBeDefined();
+    expect(result.process?.name).toBeDefined();
+  });
+
+  test('should retrieve project details with work item types from Azure DevOps', async () => {
+    // Skip if no connection is available
+    if (shouldSkipIntegrationTest()) {
+      return;
+    }
+
+    // This connection must be available if we didn't skip
+    if (!connection) {
+      throw new Error(
+        'Connection should be available when test is not skipped',
+      );
+    }
+
+    // Act - make an actual API call to Azure DevOps
+    const result = await getProjectDetails(connection, {
+      projectId: projectName,
+      includeProcess: true,
+      includeWorkItemTypes: true,
+    });
+
+    // Assert on the actual response
+    expect(result).toBeDefined();
+    expect(result.process).toBeDefined();
+    expect(result.process?.workItemTypes).toBeDefined();
+    expect(Array.isArray(result.process?.workItemTypes)).toBe(true);
+    
+    // There should be at least one work item type
+    if (result.process?.workItemTypes && result.process.workItemTypes.length > 0) {
+      const workItemType = result.process.workItemTypes[0];
+      expect(workItemType.name).toBeDefined();
+      expect(workItemType.description).toBeDefined();
+      expect(workItemType.states).toBeDefined();
+    }
+  });
+
+  test('should retrieve project details with fields from Azure DevOps', async () => {
+    // Skip if no connection is available
+    if (shouldSkipIntegrationTest()) {
+      return;
+    }
+
+    // This connection must be available if we didn't skip
+    if (!connection) {
+      throw new Error(
+        'Connection should be available when test is not skipped',
+      );
+    }
+
+    // Act - make an actual API call to Azure DevOps
+    const result = await getProjectDetails(connection, {
+      projectId: projectName,
+      includeProcess: true,
+      includeWorkItemTypes: true,
+      includeFields: true,
+    });
+
+    // Assert on the actual response
+    expect(result).toBeDefined();
+    expect(result.process).toBeDefined();
+    expect(result.process?.workItemTypes).toBeDefined();
+    
+    // There should be at least one work item type with fields
+    if (result.process?.workItemTypes && result.process.workItemTypes.length > 0) {
+      const workItemType = result.process.workItemTypes[0];
+      expect(workItemType.fields).toBeDefined();
+      expect(Array.isArray(workItemType.fields)).toBe(true);
+      
+      // There should be at least one field (like Title)
+      if (workItemType.fields && workItemType.fields.length > 0) {
+        const field = workItemType.fields[0];
+        expect(field.name).toBeDefined();
+        expect(field.referenceName).toBeDefined();
+      }
+    }
+  });
+
+  test('should throw error when project is not found', async () => {
+    // Skip if no connection is available
+    if (shouldSkipIntegrationTest()) {
+      return;
+    }
+
+    // This connection must be available if we didn't skip
+    if (!connection) {
+      throw new Error(
+        'Connection should be available when test is not skipped',
+      );
+    }
+
+    // Use a non-existent project name
+    const nonExistentProjectName = 'non-existent-project-' + Date.now();
+
+    // Act & Assert - should throw an error for non-existent project
+    await expect(
+      getProjectDetails(connection, {
+        projectId: nonExistentProjectName,
+      }),
+    ).rejects.toThrow(/not found|Failed to get project/);
+  });
+});