feat(nx-mcp): make nx_project_details more token efficient by default

Author: MaxKless

libs/nx-mcp/nx-mcp-server/src/lib/tools/nx-workspace.test.ts

@@ -1,16 +1,24 @@
-import { getTokenOptimizedToolResult, chunkContent } from './nx-workspace';
+import {
+  getTokenOptimizedToolResult,
+  chunkContent,
+  __testing__,
+} from './nx-workspace';
 import { NxWorkspace, NxError } from '@nx-console/shared-types';
 import {
   getNxJsonPrompt,
   getProjectGraphPrompt,
   getProjectGraphErrorsPrompt,
 } from '@nx-console/shared-llm-context';
 
-jest.mock('@nx-console/shared-llm-context', () => ({
-  getNxJsonPrompt: jest.fn(),
-  getProjectGraphPrompt: jest.fn(),
-  getProjectGraphErrorsPrompt: jest.fn(),
-}));
+jest.mock('@nx-console/shared-llm-context', () => {
+  const actual = jest.requireActual('@nx-console/shared-llm-context');
+  return {
+    ...actual,
+    getNxJsonPrompt: jest.fn(),
+    getProjectGraphPrompt: jest.fn(),
+    getProjectGraphErrorsPrompt: jest.fn(),
+  };
+});
 
 const mockGetNxJsonPrompt = getNxJsonPrompt as jest.MockedFunction<
   typeof getNxJsonPrompt
@@ -297,3 +305,150 @@ describe('chunkContent', () => {
     expect(page10.hasMore).toBe(false);
   });
 });
+
+describe('compressTargetForDisplay', () => {
+  const { compressTargetForDisplay } = __testing__;
+
+  it('should omit cache status when true', () => {
+    const config = {
+      executor: 'nx:run-commands',
+      command: 'echo test',
+      cache: true,
+    };
+
+    const result = compressTargetForDisplay('build', config);
+
+    expect(result).toBe("build: nx:run-commands - 'echo test'");
+    expect(result).not.toContain('cache');
+  });
+
+  it('should show cache status when false', () => {
+    const config = {
+      executor: 'nx:run-commands',
+      command: 'echo test',
+      cache: false,
+    };
+
+    const result = compressTargetForDisplay('build', config);
+
+    expect(result).toBe("build: nx:run-commands - 'echo test' | cache: false");
+  });
+
+  it('should truncate long dependency lists', () => {
+    const config = {
+      executor: '@nx/gradle:gradle',
+      dependsOn: [
+        'dep1',
+        'dep2',
+        'dep3',
+        'dep4',
+        'dep5',
+        'dep6',
+        'dep7',
+        'dep8',
+        'dep9',
+        'dep10',
+        'dep11',
+      ],
+      cache: true,
+    };
+
+    const result = compressTargetForDisplay('build', config);
+
+    expect(result).toBe(
+      'build: @nx/gradle:gradle | depends: [dep1, dep2, dep3, +8 more]',
+    );
+  });
+
+  it('should not truncate short dependency lists', () => {
+    const config = {
+      executor: '@nx/gradle:gradle',
+      dependsOn: ['dep1', 'dep2', 'dep3'],
+      cache: true,
+    };
+
+    const result = compressTargetForDisplay('build', config);
+
+    expect(result).toBe(
+      'build: @nx/gradle:gradle | depends: [dep1, dep2, dep3]',
+    );
+  });
+
+  it('should show atomized targets with abbreviated names', () => {
+    const config = {
+      executor: 'nx:noop',
+      dependsOn: ['test-ci--Test1', 'test-ci--Test2', 'test-ci--Test3'],
+      cache: true,
+    };
+    const atomizedTargets = [
+      'test-ci--Test1',
+      'test-ci--Test2',
+      'test-ci--Test3',
+    ];
+
+    const result = compressTargetForDisplay('test-ci', config, atomizedTargets);
+
+    expect(result).toBe(
+      'test-ci: nx:noop | depends: [3 atomized targets] | atomized: [Test1, Test2, Test3]',
+    );
+  });
+
+  it('should truncate long atomized target lists', () => {
+    const config = {
+      executor: 'nx:noop',
+      cache: true,
+    };
+    const atomizedTargets = [
+      'test-ci--Test1',
+      'test-ci--Test2',
+      'test-ci--Test3',
+      'test-ci--Test4',
+      'test-ci--Test5',
+      'test-ci--Test6',
+    ];
+
+    const result = compressTargetForDisplay('test-ci', config, atomizedTargets);
+
+    expect(result).toBe(
+      'test-ci: nx:noop | atomized: [Test1, Test2, Test3, +3 more]',
+    );
+  });
+
+  it('should handle target without executor', () => {
+    const config = {
+      cache: true,
+    };
+
+    const result = compressTargetForDisplay('build', config);
+
+    expect(result).toBe('build: no executor');
+  });
+
+  it('should handle nx:run-commands with multiple commands', () => {
+    const config = {
+      executor: 'nx:run-commands',
+      options: {
+        commands: ['echo test1', 'echo test2', 'echo test3'],
+      },
+      cache: true,
+    };
+
+    const result = compressTargetForDisplay('build', config);
+
+    expect(result).toBe('build: nx:run-commands - 3 commands');
+  });
+
+  it('should handle nx:run-script executor', () => {
+    const config = {
+      executor: 'nx:run-script',
+      metadata: {
+        runCommand: 'npm run test',
+      },
+      cache: true,
+    };
+
+    const result = compressTargetForDisplay('test', config);
+
+    expect(result).toBe("test: nx:run-script - 'npm run test'");
+  });
+});

libs/nx-mcp/nx-mcp-server/src/lib/tools/nx-workspace.ts

@@ -1,6 +1,7 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
 import {
+  detectAtomizedTargets,
   getGeneratorNamesAndDescriptions,
   getGeneratorSchema,
   getGeneratorsPrompt,
@@ -64,9 +65,14 @@ function getValueByPath(obj: any, path: string): any {
  *
  * @param name - The target name
  * @param config - The target configuration object
+ * @param atomizedTargets - Optional array of atomized target names for this root target
  * @returns Plain text description of the target
  */
-function compressTargetForDisplay(name: string, config: any): string {
+function compressTargetForDisplay(
+  name: string,
+  config: any,
+  atomizedTargets?: string[],
+): string {
   let description = `${name}: `;
 
   // Determine executor/command display
@@ -114,14 +120,41 @@ function compressTargetForDisplay(name: string, config: any): string {
     const deps = config.dependsOn
       .map((dep: any) => (typeof dep === 'string' ? dep : dep.target))
       .filter(Boolean);
+
     if (deps.length > 0) {
-      description += ` | depends: [${deps.join(', ')}]`;
+      // If this is a root atomizer target, simplify the dependency display
+      if (atomizedTargets && atomizedTargets.length > 0) {
+        description += ` | depends: [${atomizedTargets.length} atomized targets]`;
+      } else if (deps.length > 10) {
+        // Truncate long dependency lists
+        const firstThree = deps.slice(0, 3).join(', ');
+        description += ` | depends: [${firstThree}, +${deps.length - 3} more]`;
+      } else {
+        description += ` | depends: [${deps.join(', ')}]`;
+      }
     }
   }
 
-  // Add cache status
+  // Only show cache status if it's false (assume true by default)
   const cacheEnabled = config.cache !== false;
-  description += ` | cache: ${cacheEnabled}`;
+  if (!cacheEnabled) {
+    description += ` | cache: false`;
+  }
+
+  // Add atomized targets list if this is a root atomizer target
+  if (atomizedTargets && atomizedTargets.length > 0) {
+    // Strip the prefix from atomized target names for more compact display
+    const strippedNames = atomizedTargets.map((target) =>
+      target.replace(`${name}--`, ''),
+    );
+
+    if (strippedNames.length <= 5) {
+      description += ` | atomized: [${strippedNames.join(', ')}]`;
+    } else {
+      const firstThree = strippedNames.slice(0, 3).join(', ');
+      description += ` | atomized: [${firstThree}, +${strippedNames.length - 3} more]`;
+    }
+  }
 
   return description;
 }
@@ -377,16 +410,30 @@ export function registerNxWorkspaceTools(
           };
         }
       } else {
-        // No filter: compress targets into plain text, return rest as JSON
-        const { targets, ...projectDataWithoutTargets } = project.data;
-        detailsJson = projectDataWithoutTargets;
+        // No filter: compress targets into plain text, collapse metadata, return rest as JSON
+        const { targets, metadata, ...projectDataWithoutTargets } =
+          project.data;
+        detailsJson = {
+          ...projectDataWithoutTargets,
+          ...(metadata && {
+            metadata:
+              '<!-- COLLAPSED - use filter parameter to see details -->',
+          }),
+        };
 
         if (targets && typeof targets === 'object') {
+          // Detect atomized targets
+          const targetGroups = project.data.metadata?.targetGroups ?? {};
+          const { atomizedTargetsMap, targetsToExclude } =
+            detectAtomizedTargets(targetGroups);
+
+          // Create compressed descriptions for visible targets only
           const targetDescriptions = Object.entries(targets)
-            .map(
-              ([name, config]) =>
-                `  - ${compressTargetForDisplay(name, config)}`,
-            )
+            .filter(([name]) => !targetsToExclude.includes(name))
+            .map(([name, config]) => {
+              const atomizedTargets = atomizedTargetsMap.get(name);
+              return `  - ${compressTargetForDisplay(name, config, atomizedTargets)}`;
+            })
             .join('\n');
 
           // Pick a sample target name for the example
@@ -651,3 +698,8 @@ export function getTokenOptimizedToolResult(
 
   return [nxJsonResult, projectGraphResult, errorsResult];
 }
+
+// Export for testing
+export const __testing__ = {
+  compressTargetForDisplay,
+};

libs/shared/llm-context/src/lib/project-graph.spec.ts

@@ -1,5 +1,5 @@
 import type { ProjectGraph } from 'nx/src/devkit-exports';
-import { getProjectGraphPrompt } from './project-graph';
+import { detectAtomizedTargets, getProjectGraphPrompt } from './project-graph';
 
 describe('project-graph', () => {
   describe('getProjectGraphPrompt', () => {
@@ -385,4 +385,77 @@ describe('project-graph', () => {
       });
     });
   });
+
+  describe('detectAtomizedTargets', () => {
+    it('should detect atomized targets correctly', () => {
+      const targetGroups = {
+        'test-ci': [
+          'test-ci',
+          'test-ci--Test1',
+          'test-ci--Test2',
+          'test-ci--Test3',
+        ],
+      };
+
+      const result = detectAtomizedTargets(targetGroups);
+
+      expect(result.rootTargets).toEqual(new Set(['test-ci']));
+      expect(result.atomizedTargetsMap.get('test-ci')).toEqual([
+        'test-ci--Test1',
+        'test-ci--Test2',
+        'test-ci--Test3',
+      ]);
+      expect(result.targetsToExclude).toEqual([
+        'test-ci--Test1',
+        'test-ci--Test2',
+        'test-ci--Test3',
+      ]);
+    });
+
+    it('should handle multiple root targets', () => {
+      const targetGroups = {
+        'test-ci': ['test-ci', 'test-ci--Test1', 'test-ci--Test2'],
+        'e2e-ci': ['e2e-ci', 'e2e-ci--Test1', 'e2e-ci--Test2'],
+      };
+
+      const result = detectAtomizedTargets(targetGroups);
+
+      expect(result.rootTargets).toEqual(new Set(['test-ci', 'e2e-ci']));
+      expect(result.atomizedTargetsMap.get('test-ci')).toEqual([
+        'test-ci--Test1',
+        'test-ci--Test2',
+      ]);
+      expect(result.atomizedTargetsMap.get('e2e-ci')).toEqual([
+        'e2e-ci--Test1',
+        'e2e-ci--Test2',
+      ]);
+      expect(result.targetsToExclude).toEqual([
+        'test-ci--Test1',
+        'test-ci--Test2',
+        'e2e-ci--Test1',
+        'e2e-ci--Test2',
+      ]);
+    });
+
+    it('should handle empty targetGroups', () => {
+      const result = detectAtomizedTargets({});
+
+      expect(result.rootTargets).toEqual(new Set());
+      expect(result.atomizedTargetsMap.size).toBe(0);
+      expect(result.targetsToExclude).toEqual([]);
+    });
+
+    it('should handle groups without atomized targets', () => {
+      const targetGroups = {
+        build: ['build'],
+        test: ['test'],
+      };
+
+      const result = detectAtomizedTargets(targetGroups);
+
+      expect(result.rootTargets).toEqual(new Set());
+      expect(result.atomizedTargetsMap.size).toBe(0);
+      expect(result.targetsToExclude).toEqual([]);
+    });
+  });
 });