✨ feat: add search command for package and workspace dependencies, refactor dependency architecture, and update documentation

Author: lennondotw

CHANGELOG.md

@@ -8,6 +8,14 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/), and this
 
 ## [Unreleased]
 
+### Added
+
+- Command: Search in Package and Workspace Dependencies... - Select a package and open VS Code search with the package and its workspace dependencies pre-filled
+
+### Changed
+
+- Refactored workspace dependencies architecture for better code reusability
+
 ## [0.2.1] - 2025-07-23
 
 ### Added

README.md

@@ -4,10 +4,11 @@ A comprehensive VS Code extension providing productivity tools for pnpm workspac
 
 ## 🚀 Current Features
 
-**Copy Workspace Dependencies** - Two powerful ways to extract workspace dependency information!
+**Workspace Productivity Tools** - Comprehensive utilities for pnpm workspace projects!
 
 - **Copy Workspace Dependency Names**: Select any package in your pnpm workspace and copy its workspace dependency names to clipboard, with each dependency on a new line
 - **Copy Workspace Dependency Paths**: Select any package in your pnpm workspace and copy its workspace dependency paths to clipboard, with each dependency path on a new line
+- **Search in Package and Workspace Dependencies**: Select a package and open VS Code search with the package and all its workspace dependencies pre-filled in the search scope
 - **Re-scan Workspace**: Manually refresh the workspace package cache when needed
 - **Web Extension Support**: Works in VS Code for the Web and remote development environments
 - **Workspace Root Support**: Includes the workspace root package with special marking
@@ -28,6 +29,7 @@ This extension contributes the following commands:
 
 - `pnpm Workspace: Copy Workspace Dependency Names Of...` - Opens a quick picker to select a package and copies its workspace dependency names
 - `pnpm Workspace: Copy Workspace Dependency Paths Of...` - Opens a quick picker to select a package and copies its workspace dependency paths
+- `pnpm Workspace: Search in Package and Workspace Dependencies...` - Opens a quick picker to select a package and opens search with the package and its dependencies
 - `pnpm Workspace: Re-scan Workspace Packages` - Clears the package cache and re-scans the workspace
 
 ## Usage
@@ -46,6 +48,14 @@ This extension contributes the following commands:
 3. Select the package you want to get dependency paths for
 4. The workspace dependency paths will be copied to your clipboard, separated by newlines
 
+### Search in Package and Workspace Dependencies
+
+1. Open a pnpm workspace (a project with `pnpm-workspace.yaml`)
+2. Run `pnpm Workspace: Search in Package and Workspace Dependencies...` from the Command Palette
+3. Select the package you want to search in along with its dependencies
+4. VS Code's search panel will open with the package and its workspace dependencies pre-filled in the "files to include" field
+5. Enter your search term and the search will be scoped to only those packages
+
 The extension automatically scans your workspace on first use and caches the results. Use the re-scan command if you've added or removed packages.
 
 ## Configuration

package.json

@@ -70,6 +70,11 @@
         "title": "pnpm Workspace: Copy Workspace Dependency Paths Of...",
         "shortTitle": "Copy Workspace Dependency Paths"
       },
+      {
+        "command": "pnpm-workspace.searchInPackageAndWorkspaceDependencies",
+        "title": "pnpm Workspace: Search in Package and Workspace Dependencies...",
+        "shortTitle": "Search in Package and Dependencies"
+      },
       {
         "command": "pnpm-workspace.rescanWorkspacePackages",
         "title": "pnpm Workspace: Re-scan Workspace Packages",

src/commands.ts

@@ -2,8 +2,9 @@ import * as vscode from 'vscode';
 import { log, logError } from './logger.js';
 import {
   clearPackageCache,
-  getWorkspaceDependencies,
+  getPackageAndDependencyPaths,
   getWorkspaceDependencyNames,
+  getWorkspaceDependencyPaths,
   getWorkspacePackages,
   type WorkspacePackage,
 } from './pnpm-workspace.js';
@@ -201,7 +202,7 @@ export function registerCommands(context: vscode.ExtensionContext) {
           return;
         }
 
-        const dependencyPaths = await getWorkspaceDependencies(selected.package.name);
+        const dependencyPaths = await getWorkspaceDependencyPaths(selected.package.name);
         if (dependencyPaths.length === 0) {
           vscode.window.showInformationMessage(`Package "${selected.package.name}" has no workspace dependencies.`);
           return;
@@ -221,6 +222,119 @@ export function registerCommands(context: vscode.ExtensionContext) {
     }
   );
 
+  // Search in Package and Workspace Dependencies...
+  const searchInPackageAndWorkspaceDependencies = vscode.commands.registerCommand(
+    'pnpm-workspace.searchInPackageAndWorkspaceDependencies',
+    async () => {
+      log('=================================');
+      log('Executing searchInPackageAndWorkspaceDependencies command');
+
+      try {
+        // Create and show QuickPick immediately with loading state
+        const quickPick = vscode.window.createQuickPick();
+        quickPick.placeholder = 'Select a package to search in it and its workspace dependencies';
+        quickPick.matchOnDescription = true;
+        quickPick.busy = true;
+        quickPick.items = [{ label: 'Loading packages...', description: 'Scanning workspace' }];
+        quickPick.show();
+
+        let packages: WorkspacePackage[];
+        try {
+          // Load packages in background
+          packages = await getWorkspacePackages();
+        } catch (error) {
+          quickPick.hide();
+          logError('Failed to load workspace packages', error);
+          vscode.window.showErrorMessage('Failed to load workspace packages');
+          return;
+        }
+
+        if (packages.length === 0) {
+          quickPick.hide();
+          vscode.window.showErrorMessage(
+            'No pnpm workspace packages found. Make sure you have a pnpm-workspace.yaml file.'
+          );
+          return;
+        }
+
+        // Update QuickPick with actual packages
+        interface QuickPickItemWithPackage extends vscode.QuickPickItem {
+          package: WorkspacePackage;
+        }
+
+        const items: QuickPickItemWithPackage[] = packages
+          .sort((a, b) => {
+            // Workspace root always comes first
+            if (a.isRoot && !b.isRoot) {
+              return -1;
+            }
+            if (!a.isRoot && b.isRoot) {
+              return 1;
+            }
+            // @ packages come after regular packages
+            const aStartsWithAt = a.name.startsWith('@');
+            const bStartsWithAt = b.name.startsWith('@');
+            if (!aStartsWithAt && bStartsWithAt) {
+              return -1;
+            }
+            if (aStartsWithAt && !bStartsWithAt) {
+              return 1;
+            }
+            // Otherwise sort alphabetically by name
+            return a.name.localeCompare(b.name);
+          })
+          .map((pkg: WorkspacePackage) => ({
+            label: pkg.isRoot ? `${pkg.name} (Workspace Root)` : pkg.name,
+            description: pkg.path,
+            package: pkg,
+          }));
+
+        quickPick.busy = false;
+        quickPick.items = items;
+
+        // Wait for user selection
+        const selected = await new Promise<QuickPickItemWithPackage | undefined>((resolve) => {
+          quickPick.onDidAccept(() => {
+            const selection = quickPick.selectedItems[0] as QuickPickItemWithPackage;
+            quickPick.hide();
+            resolve(selection);
+          });
+          quickPick.onDidHide(() => {
+            resolve(undefined);
+          });
+        });
+
+        if (!selected) {
+          return;
+        }
+
+        // Get all paths (package + dependencies)
+        const allPaths = await getPackageAndDependencyPaths(selected.package.name);
+        if (allPaths.length === 0) {
+          vscode.window.showInformationMessage(`No paths found for package "${selected.package.name}".`);
+          return;
+        }
+
+        // Format paths for search (comma-space separated)
+        const searchPaths = allPaths.join(', ');
+        log(`Opening search with paths: ${searchPaths}`);
+
+        // Open search view with paths pre-filled
+        await vscode.commands.executeCommand('workbench.action.findInFiles', {
+          filesToInclude: searchPaths,
+          triggerSearch: false, // Don't auto-search, let user enter search term
+        });
+
+        vscode.window.showInformationMessage(
+          `Opened search in ${allPaths.length} locations: ${selected.package.name} and its ${allPaths.length - 1} dependencies.`
+        );
+      } catch (error) {
+        logError('Failed to search in package and workspace dependencies', error);
+        vscode.window.showErrorMessage('Failed to search in package and workspace dependencies');
+      }
+    }
+  );
+
   // Re-scan Workspace Packages
   const rescanWorkspacePackages = vscode.commands.registerCommand(
     'pnpm-workspace.rescanWorkspacePackages',
@@ -255,5 +369,10 @@ export function registerCommands(context: vscode.ExtensionContext) {
     }
   );
 
-  context.subscriptions.push(copyWorkspaceDependencyNames, copyWorkspaceDependencyPaths, rescanWorkspacePackages);
+  context.subscriptions.push(
+    copyWorkspaceDependencyNames,
+    copyWorkspaceDependencyPaths,
+    searchInPackageAndWorkspaceDependencies,
+    rescanWorkspacePackages
+  );
 }

src/pnpm-workspace.ts

@@ -5,6 +5,7 @@ import { WorkspacePackage, discoverPackages, loadPackageInfo } from './package-s
 import {
   getWorkspaceDependencies as getWorkspaceDependenciesFromPackage,
   getWorkspaceDependencyNames as getWorkspaceDependencyNamesFromPackage,
+  getWorkspaceDependencyPaths as getWorkspaceDependencyPathsFromPackage,
 } from './workspace-dependencies.js';
 import { findPnpmWorkspaceFiles, loadWorkspaceConfig } from './workspace-discovery.js';
 
@@ -137,9 +138,44 @@ export async function getWorkspaceDependencyNames(packageName: string): Promise<
 }
 
 /**
- * Gets workspace dependency paths for a specific package
+ * Gets workspace dependencies as objects with name and path
  */
-export async function getWorkspaceDependencies(packageName: string): Promise<string[]> {
+export async function getWorkspaceDependencies(packageName: string): Promise<{ name: string; path: string }[]> {
   const packages = await getWorkspacePackages();
   return await getWorkspaceDependenciesFromPackage(packageName, packages);
 }
+
+/**
+ * Gets workspace dependency paths only
+ */
+export async function getWorkspaceDependencyPaths(packageName: string): Promise<string[]> {
+  const packages = await getWorkspacePackages();
+  return await getWorkspaceDependencyPathsFromPackage(packageName, packages);
+}
+
+/**
+ * Gets all paths for a package and its workspace dependencies (for searching)
+ */
+export async function getPackageAndDependencyPaths(packageName: string): Promise<string[]> {
+  const packages = await getWorkspacePackages();
+
+  // Find the target package
+  const targetPackage = packages.find((pkg) => pkg.name === packageName);
+  if (!targetPackage) {
+    log(`Target package ${packageName} not found in workspace`);
+    return [];
+  }
+
+  const allPaths: string[] = [];
+
+  // Add the target package path first
+  allPaths.push(targetPackage.path);
+  log(`Added target package path: ${targetPackage.path}`);
+
+  // Get workspace dependency paths
+  const dependencyPaths = await getWorkspaceDependencyPathsFromPackage(packageName, packages);
+  allPaths.push(...dependencyPaths);
+
+  log(`Final paths for search (${packageName} + dependencies): [${allPaths.join(', ')}]`);
+  return allPaths;
+}

src/test/simple-integration.test.ts

@@ -1,5 +1,11 @@
 import * as assert from 'assert';
-import { clearPackageCache, getWorkspaceDependencies, getWorkspaceDependencyNames } from '../pnpm-workspace.js';
+import {
+  clearPackageCache,
+  getPackageAndDependencyPaths,
+  getWorkspaceDependencies,
+  getWorkspaceDependencyNames,
+  getWorkspaceDependencyPaths,
+} from '../pnpm-workspace.js';
 
 suite('Simple Integration Tests', () => {
   setup(() => {
@@ -17,28 +23,37 @@ suite('Simple Integration Tests', () => {
     const { WorkspaceConfigSchema } = await import('../schemas.js');
     const { findPnpmWorkspaceFiles } = await import('../workspace-discovery.js');
     const { loadPackageInfo } = await import('../package-scanner.js');
-    const { getWorkspaceDependencies, getWorkspaceDependencyNames } = await import('../workspace-dependencies.js');
+    const { getWorkspaceDependencies, getWorkspaceDependencyNames, getWorkspaceDependencyPaths } = await import(
+      '../workspace-dependencies.js'
+    );
 
     assert.ok(WorkspaceConfigSchema, 'Schema module loaded');
     assert.ok(findPnpmWorkspaceFiles, 'Workspace discovery module loaded');
     assert.ok(loadPackageInfo, 'Package scanner module loaded');
     assert.ok(getWorkspaceDependencies, 'Workspace dependencies module loaded');
     assert.ok(getWorkspaceDependencyNames, 'Workspace dependency names module loaded');
+    assert.ok(getWorkspaceDependencyPaths, 'Workspace dependency paths module loaded');
   });
 
-  test('should differentiate between dependency names and paths', async () => {
-    // Test that both functions exist and can be called
+  test('should differentiate between dependency names, paths, and search paths', async () => {
+    // Test that all functions exist and can be called
     assert.ok(typeof getWorkspaceDependencyNames === 'function', 'getWorkspaceDependencyNames should be a function');
     assert.ok(typeof getWorkspaceDependencies === 'function', 'getWorkspaceDependencies should be a function');
+    assert.ok(typeof getWorkspaceDependencyPaths === 'function', 'getWorkspaceDependencyPaths should be a function');
+    assert.ok(typeof getPackageAndDependencyPaths === 'function', 'getPackageAndDependencyPaths should be a function');
 
     // Note: These functions require a valid workspace to return meaningful results
     // In this test environment, they will return empty arrays, but should not throw errors
     try {
       const names = await getWorkspaceDependencyNames('test-package');
-      const paths = await getWorkspaceDependencies('test-package');
+      const dependencies = await getWorkspaceDependencies('test-package');
+      const paths = await getWorkspaceDependencyPaths('test-package');
+      const searchPaths = await getPackageAndDependencyPaths('test-package');
 
       assert.ok(Array.isArray(names), 'getWorkspaceDependencyNames should return an array');
-      assert.ok(Array.isArray(paths), 'getWorkspaceDependencies should return an array');
+      assert.ok(Array.isArray(dependencies), 'getWorkspaceDependencies should return an array');
+      assert.ok(Array.isArray(paths), 'getWorkspaceDependencyPaths should return an array');
+      assert.ok(Array.isArray(searchPaths), 'getPackageAndDependencyPaths should return an array');
     } catch (error) {
       // Expected to fail in test environment without valid workspace
       assert.ok(error, 'Functions should handle missing workspace gracefully');