feat: add 'expand' option to get_work_item

Enhanced the get_work_item tool to support the WorkItemExpand option.
It will default to WorkItemExpand.All when no specific fields are requested,
providing more complete information in the response.

Author: Tiberriver256

docs/tools/work-items.md

@@ -17,7 +17,7 @@ Retrieves a work item by its ID.
 | Parameter    | Type   | Required | Description                                                                       |
 | ------------ | ------ | -------- | --------------------------------------------------------------------------------- |
 | `workItemId` | number | Yes      | The ID of the work item to retrieve                                               |
-| `expand`     | string | No       | Controls the level of detail in the response (e.g., "All", "Relations", "Fields") |
+| `expand`     | string | No       | Controls the level of detail in the response. Defaults to "All" if not specified. Other values: "Relations", "Fields", "None" |
 
 ### Response
 
@@ -45,9 +45,16 @@ Returns a work item object with the following structure:
 ### Example Usage
 
 ```javascript
+// Using default expand="All"
 const result = await callTool('get_work_item', {
   workItemId: 123,
 });
+
+// Explicitly specifying expand
+const minimalResult = await callTool('get_work_item', {
+  workItemId: 123,
+  expand: 'None'
+});
 ```
 
 ## create_work_item

project-management/task-management/doing.md

@@ -1 +1,3 @@
+## Current Task
 
+No task is currently in progress. Please take the next task from todo.md.

project-management/task-management/done.md

@@ -1,5 +1,20 @@
 ## Completed Tasks
 
+- [x] **Task 2.8**: Allow `get_work_item` to default to 'Expand All' when no specific fields are requested. There isn't usually enough information on the default Get_work_item response now.
+  - **Role**: Full-Stack Developer
+  - **Phase**: Completed
+  - **Notes**:
+    - Current implementation in `src/features/work-items/get-work-item/feature.ts` only requested minimal fields by default
+    - Azure DevOps API supports WorkItemExpand enum with options: None, Relations, Fields, Links, All
+    - When using expand parameter, we should not specify fields array
+    - Current schema in `src/features/work-items/schemas.ts` didn't expose expand parameter
+  - **Implementation**:
+    - Updated `GetWorkItemSchema` in `src/features/work-items/schemas.ts` to include the optional expand parameter
+    - Modified `getWorkItem` function in `src/features/work-items/get-work-item/feature.ts` to use `WorkItemExpand.All` by default
+    - Updated documentation in `docs/tools/work-items.md` to reflect the new default behavior
+    - Added tests in `src/features/work-items/get-work-item/feature.spec.int.ts` to verify the expanded data retrieval
+  - **Completed**: March 31, 2024
+
 - [x] **Task 1.0**: Implement `manage_work_item_link` handler with tests
   - **Role**: Full-Stack Developer
   - **Phase**: Completed

project-management/task-management/todo.md

@@ -1,7 +1,5 @@
 ## Azure DevOps MCP Server Project TODO List (Granular Daily Tasks)
 
-- [ ] **Task 2.8**: Implement `get_work_item` handler with tests
-  - **Role**: Full-Stack Developer
 - [ ] **Task 2.10**: Implement `add_work_item_comment` handler with tests
   - **Role**: Full-Stack Developer
 - [ ] **Task 2.13**: Refactor work item tools for consistency (with regression tests)

src/features/work-items/get-work-item/feature.spec.int.ts

@@ -5,82 +5,169 @@ import {
   shouldSkipIntegrationTest,
 } from '../__test__/test-helpers';
 import { WorkItemExpand } from 'azure-devops-node-api/interfaces/WorkItemTrackingInterfaces';
+import { AzureDevOpsResourceNotFoundError } from '../../../shared/errors';
+import { createWorkItem } from '../create-work-item/feature';
+import { manageWorkItemLink } from '../manage-work-item-link/feature';
+import { CreateWorkItemOptions } from '../types';
 
 describe('getWorkItem integration', () => {
   let connection: WebApi | null = null;
+  let testWorkItemId: number | null = null;
+  let linkedWorkItemId: number | 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';
 
-  // This test requires that work item #1 exists in the default project
-  test('should retrieve a real work item from Azure DevOps', async () => {
-    // Skip if no connection is available
-    if (shouldSkipIntegrationTest()) {
+    // Skip setup if integration tests should be skipped
+    if (shouldSkipIntegrationTest() || !connection) {
       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',
+    try {
+      // Create a test work item
+      const uniqueTitle = `Test Work Item ${new Date().toISOString()}`;
+      const options: CreateWorkItemOptions = {
+        title: uniqueTitle,
+        description: 'Test work item for get-work-item integration tests',
+      };
+
+      const testWorkItem = await createWorkItem(
+        connection,
+        projectName,
+        'Task',
+        options,
+      );
+
+      // Create another work item to link to the first one
+      const linkedItemOptions: CreateWorkItemOptions = {
+        title: `Linked Work Item ${new Date().toISOString()}`,
+        description: 'Linked work item for get-work-item integration tests',
+      };
+
+      const linkedWorkItem = await createWorkItem(
+        connection,
+        projectName,
+        'Task',
+        linkedItemOptions,
       );
+
+      if (testWorkItem?.id && linkedWorkItem?.id) {
+        testWorkItemId = testWorkItem.id;
+        linkedWorkItemId = linkedWorkItem.id;
+
+        // Create a link between the two work items
+        await manageWorkItemLink(connection, projectName, {
+          sourceWorkItemId: testWorkItemId,
+          targetWorkItemId: linkedWorkItemId,
+          operation: 'add',
+          relationType: 'System.LinkTypes.Related',
+          comment: 'Link created for get-work-item integration tests',
+        });
+      }
+    } catch (error) {
+      console.error('Failed to create test work items:', error);
     }
+  });
 
-    // For a true integration test, use a known work item ID that exists
-    const workItemId = 1; // This assumes work item #1 exists in your project
+  test('should retrieve a real work item from Azure DevOps with default expand=all', async () => {
+    // Skip if no connection is available
+    if (shouldSkipIntegrationTest() || !connection || !testWorkItemId) {
+      return;
+    }
 
-    // Act - make an actual API call to Azure DevOps
-    const result = await getWorkItem(connection, workItemId);
+    // Act - get work item by ID
+    const result = await getWorkItem(connection, testWorkItemId);
 
-    // Assert on the actual response
+    // Assert
     expect(result).toBeDefined();
-    expect(result.id).toBe(workItemId);
+    expect(result.id).toBe(testWorkItemId);
 
-    // Verify fields exist
+    // Verify expanded fields and data are present
     expect(result.fields).toBeDefined();
+    expect(result._links).toBeDefined();
+
+    // With expand=all and a linked item, relations should be defined
+    expect(result.relations).toBeDefined();
+
     if (result.fields) {
-      // Don't make assumptions about specific field values, just verify structure
+      // Verify common fields that should be present with expand=all
       expect(result.fields['System.Title']).toBeDefined();
+      expect(result.fields['System.State']).toBeDefined();
+      expect(result.fields['System.CreatedDate']).toBeDefined();
+      expect(result.fields['System.ChangedDate']).toBeDefined();
     }
   });
 
   test('should retrieve work item with expanded relations', async () => {
     // Skip if no connection is available
-    if (shouldSkipIntegrationTest()) {
+    if (shouldSkipIntegrationTest() || !connection || !testWorkItemId) {
       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',
-      );
-    }
-
-    // For a true integration test, use a known work item ID that exists
-    const workItemId = 1; // This assumes work item #1 exists in your project
-
-    // Act - make an actual API call to Azure DevOps with expanded relations
+    // Act - get work item with relations expansion
     const result = await getWorkItem(
       connection,
-      workItemId,
+      testWorkItemId,
       WorkItemExpand.Relations,
     );
 
-    // Assert on the actual response
+    // Assert
     expect(result).toBeDefined();
-    expect(result.id).toBe(workItemId);
+    expect(result.id).toBe(testWorkItemId);
+
+    // When using expand=relations on a work item with links, relations should be defined
+    expect(result.relations).toBeDefined();
 
-    // When using expand, we may get additional information beyond just fields
-    // For example, revision, url, _links, etc.
-    expect(result._links || result.url || result.rev).toBeTruthy();
+    // Verify we can access the related work item
+    if (result.relations && result.relations.length > 0) {
+      const relation = result.relations[0];
+      expect(relation.rel).toBe('System.LinkTypes.Related');
+      expect(relation.url).toContain(linkedWorkItemId?.toString());
+    }
 
     // Verify fields exist
     expect(result.fields).toBeDefined();
     if (result.fields) {
       expect(result.fields['System.Title']).toBeDefined();
     }
   });
+
+  test('should retrieve work item with minimal fields when using expand=none', async () => {
+    if (shouldSkipIntegrationTest() || !connection || !testWorkItemId) {
+      return;
+    }
+
+    // Act - get work item with no expansion
+    const result = await getWorkItem(
+      connection,
+      testWorkItemId,
+      WorkItemExpand.None,
+    );
+
+    // Assert
+    expect(result).toBeDefined();
+    expect(result.id).toBe(testWorkItemId);
+    expect(result.fields).toBeDefined();
+
+    // With expand=none, we should still get _links but no relations
+    // The Azure DevOps API still returns _links even with expand=none
+    expect(result.relations).toBeUndefined();
+  });
+
+  test('should throw AzureDevOpsResourceNotFoundError for non-existent work item', async () => {
+    if (shouldSkipIntegrationTest() || !connection) {
+      return;
+    }
+
+    // Use a very large ID that's unlikely to exist
+    const nonExistentId = 999999999;
+
+    // Assert that it throws the correct error
+    await expect(getWorkItem(connection, nonExistentId)).rejects.toThrow(
+      AzureDevOpsResourceNotFoundError,
+    );
+  });
 });

src/features/work-items/get-work-item/feature.ts

@@ -11,28 +11,25 @@ import { WorkItem } from '../types';
  *
  * @param connection The Azure DevOps WebApi connection
  * @param workItemId The ID of the work item
- * @param expand Optional expansion options
+ * @param expand Optional expansion options (defaults to WorkItemExpand.All)
  * @returns The work item details
  * @throws {AzureDevOpsResourceNotFoundError} If the work item is not found
  */
 export async function getWorkItem(
   connection: WebApi,
   workItemId: number,
-  expand?: WorkItemExpand,
+  expand: WorkItemExpand = WorkItemExpand.All,
 ): Promise<WorkItem> {
   try {
     const witApi = await connection.getWorkItemTrackingApi();
-    const fields = [
-      'System.Id',
-      'System.Title',
-      'System.State',
-      'System.AssignedTo',
-    ];
 
-    // Don't pass fields when using expand parameter
-    const workItem = expand
-      ? await witApi.getWorkItem(workItemId, undefined, undefined, expand)
-      : await witApi.getWorkItem(workItemId, fields);
+    // Always use expand parameter for consistent behavior
+    const workItem = await witApi.getWorkItem(
+      workItemId,
+      undefined,
+      undefined,
+      expand,
+    );
 
     if (!workItem) {
       throw new AzureDevOpsResourceNotFoundError(

src/features/work-items/schemas.ts

@@ -1,10 +1,17 @@
 import { z } from 'zod';
+import { WorkItemExpand } from 'azure-devops-node-api/interfaces/WorkItemTrackingInterfaces';
 
 /**
  * Schema for getting a work item
  */
 export const GetWorkItemSchema = z.object({
   workItemId: z.number().describe('The ID of the work item'),
+  expand: z
+    .nativeEnum(WorkItemExpand)
+    .optional()
+    .describe(
+      'The level of detail to include in the response. Defaults to "all" if not specified.',
+    ),
 });
 
 /**

src/server.ts

@@ -180,7 +180,11 @@ export function createAzureDevOpsServer(config: AzureDevOpsConfig): Server {
         // Work item tools
         case 'get_work_item': {
           const args = GetWorkItemSchema.parse(request.params.arguments);
-          const result = await getWorkItem(connection, args.workItemId);
+          const result = await getWorkItem(
+            connection,
+            args.workItemId,
+            args.expand,
+          );
           return {
             content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
           };