Function findFiles

packages/foam-vscode/src/test/vscode-mock.ts:1899–1956

(
    include: string,
    exclude?: string,
    maxResults?: number
  )

  },

  async findFiles(
    include: string,
    exclude?: string,
    maxResults?: number
  ): Promise<Uri[]> {
    // Simple implementation that recursively finds files
    const workspaceFolder = mockState.workspaceFolders[0];

    if (!workspaceFolder) {
      return [];
    }

    const findFilesRecursive = async (dir: string): Promise<string[]> => {
      const files: string[] = [];
      try {
        const entries = await fs.promises.readdir(dir, { withFileTypes: true });

        for (const entry of entries) {
          const fullPath = path.join(dir, entry.name);
          const relativePath = path
            .relative(workspaceFolder.uri.fsPath, fullPath)
            .split(path.sep)
            .join('/');

          if (entry.isDirectory()) {
            const subFiles = await findFilesRecursive(fullPath);
            files.push(...subFiles);
          } else if (entry.isFile()) {
            // Check if file matches include pattern
            if (micromatch.isMatch(relativePath, include)) {
              // Check if file matches exclude pattern
              if (!exclude || !micromatch.isMatch(relativePath, exclude)) {
                files.push(fullPath);
              }
            }
          }
        }
      } catch (error) {
        // Ignore errors accessing directories
      }

      return files;
    };

    try {
      const files = await findFilesRecursive(workspaceFolder.uri.fsPath);

      let result = files.map(file => createVSCodeUri(URI.file(file)));

      if (maxResults && result.length > maxResults) {
        result = result.slice(0, maxResults);
      }

      return result;
    } catch (error) {
      return [];
    }
  },