@featurevisor/core 2.26.1 → 3.0.1

package/src/evaluate/index.ts

@@ -1,17 +1,18 @@
 import type { Context, DatafileContent } from "@featurevisor/types";
-import {
-  Evaluation,
-  createInstance,
-  createLogger,
-  LogLevel,
-  LogMessage,
-  LogDetails,
-} from "@featurevisor/sdk";
+import { createFeaturevisor } from "@featurevisor/sdk";
+import type { Evaluation, FeaturevisorDiagnostic } from "@featurevisor/sdk";
 
 import { Dependencies } from "../dependencies";
-import { SCHEMA_VERSION } from "../config";
-import { buildDatafile } from "../builder";
+import { buildRuntimeDatafiles } from "../builder/buildRuntimeDatafiles";
 import { Plugin } from "../cli";
+import { assertProjectSetJsonSelection, getProjectSetExecutions, printSetHeader } from "../sets";
+import {
+  CLI_COLOR_CYAN,
+  CLI_FORMAT_BOLD,
+  CLI_FORMAT_GREEN,
+  CLI_FORMAT_YELLOW,
+  colorize,
+} from "../tester/cliFormat";
 
 function printEvaluationDetails(evaluation: Evaluation) {
   const ignoreKeys = ["featureKey", "variableKey", "traffic", "force"];
@@ -22,31 +23,35 @@ function printEvaluationDetails(evaluation: Evaluation) {
     }
 
     if (key === "variation") {
-      console.log(`-`, `${key}:`, value?.value);
+      console.log(`  ${colorize(key, CLI_COLOR_CYAN)}:`, value?.value);
       continue;
     }
 
     if (key === "variableSchema") {
-      console.log(`-`, `variableType:`, value.type);
-      console.log(`-`, `defaultValue:`, value.defaultValue);
+      console.log(`  ${colorize("variableType", CLI_COLOR_CYAN)}:`, value.type);
+      console.log(`  ${colorize("defaultValue", CLI_COLOR_CYAN)}:`, value.defaultValue);
       continue;
     }
 
-    console.log(`-`, `${key}:`, value);
+    console.log(`  ${colorize(key, CLI_COLOR_CYAN)}:`, value);
   }
 }
 
-function printLogs(logs: Log[]) {
-  logs.forEach((log) => {
-    console.log(`[${log.level}] ${log.message}`, log.details);
+function printDiagnostics(diagnostics: FeaturevisorDiagnostic[]) {
+  diagnostics.forEach((diagnostic) => {
+    const levelColor = diagnostic.level === "error" ? 31 : diagnostic.level === "warn" ? 33 : 2;
+    console.log(
+      `${colorize(`[${diagnostic.level}]`, levelColor)} ${diagnostic.message}`,
+      diagnostic,
+    );
     console.log("");
   });
 }
 
 function printHeader(message: string) {
-  console.log("\n\n###############");
-  console.log(`# ${message}`);
-  console.log("###############\n");
+  console.log("");
+  console.log(CLI_FORMAT_BOLD, message);
+  console.log("");
 }
 
 export interface EvaluateOptions {
@@ -56,57 +61,32 @@ export interface EvaluateOptions {
   json?: boolean;
   pretty?: boolean;
   verbose?: boolean;
-  schemaVersion?: string;
   inflate?: number;
+  target?: string | string[];
 }
 
-export interface Log {
-  level: LogLevel;
-  message: LogMessage;
-  details?: LogDetails;
-}
-
-export async function evaluateFeature(deps: Dependencies, options: EvaluateOptions) {
-  const { datasource, projectConfig } = deps;
-
-  const existingState = await datasource.readState(options.environment || false);
-  const datafileContent = await buildDatafile(
-    projectConfig,
-    datasource,
-    {
-      schemaVersion: options.schemaVersion || SCHEMA_VERSION,
-      revision: "include-all-features",
-      environment: options.environment || false,
-      inflate: options.inflate,
-    },
-    existingState,
-  );
-
-  let logs: Log[] = [];
-  const f = createInstance({
+async function evaluateFeatureWithDatafile(
+  datafileContent: DatafileContent,
+  options: EvaluateOptions,
+  target?: string,
+) {
+  let diagnostics: FeaturevisorDiagnostic[] = [];
+  const f = createFeaturevisor({
     datafile: datafileContent as DatafileContent,
-    logger: createLogger({
-      level: "debug",
-      handler: (level, message, details) => {
-        logs.push({
-          level,
-          message,
-          details,
-        });
-      },
-    }),
+    logLevel: "debug",
+    onDiagnostic: (diagnostic) => diagnostics.push(diagnostic),
   });
 
   const flagEvaluation = f.evaluateFlag(options.feature, options.context as Context);
-  const flagEvaluationLogs = [...logs];
-  logs = [];
+  const flagEvaluationDiagnostics = [...diagnostics];
+  diagnostics = [];
 
   const variationEvaluation = f.evaluateVariation(options.feature, options.context as Context);
-  const variationEvaluationLogs = [...logs];
-  logs = [];
+  const variationEvaluationDiagnostics = [...diagnostics];
+  diagnostics = [];
 
   const variableEvaluations: Record<string, Evaluation> = {};
-  const variableEvaluationLogs: Record<string, Log[]> = {};
+  const variableEvaluationDiagnostics: Record<string, FeaturevisorDiagnostic[]> = {};
 
   const feature = f.getFeature(options.feature);
   if (feature?.variablesSchema) {
@@ -121,8 +101,8 @@ export async function evaluateFeature(deps: Dependencies, options: EvaluateOptio
         options.context as Context,
       );
 
-      variableEvaluationLogs[variableKey] = [...logs];
-      logs = [];
+      variableEvaluationDiagnostics[variableKey] = [...diagnostics];
+      diagnostics = [];
 
       variableEvaluations[variableKey] = variableEvaluation;
     });
@@ -135,25 +115,27 @@ export async function evaluateFeature(deps: Dependencies, options: EvaluateOptio
   };
 
   if (options.json) {
-    console.log(
-      options.pretty ? JSON.stringify(allEvaluations, null, 2) : JSON.stringify(allEvaluations),
-    );
-
-    return;
+    return allEvaluations;
   }
 
   console.log("");
-  console.log(`Evaluating feature "${options.feature}" in environment "${options.environment}"...`);
-  console.log(`Against context: ${JSON.stringify(options.context)}`);
+  console.log(CLI_FORMAT_BOLD, "Evaluating Featurevisor feature");
+  console.log(`  ${colorize("Feature", CLI_COLOR_CYAN)}: ${options.feature}`);
+  console.log(`  ${colorize("Environment", CLI_COLOR_CYAN)}: ${options.environment || false}`);
+  if (target) console.log(`  ${colorize("Target", CLI_COLOR_CYAN)}: ${target}`);
+  console.log(`  ${colorize("Context", CLI_COLOR_CYAN)}: ${JSON.stringify(options.context)}`);
 
   // flag
   printHeader("Is enabled?");
 
   if (options.verbose) {
-    printLogs(flagEvaluationLogs);
+    printDiagnostics(flagEvaluationDiagnostics);
   }
 
-  console.log("Value:", flagEvaluation.enabled);
+  console.log(
+    flagEvaluation.enabled ? CLI_FORMAT_GREEN : CLI_FORMAT_YELLOW,
+    `Value: ${flagEvaluation.enabled}`,
+  );
   console.log("\nDetails:\n");
 
   printEvaluationDetails(flagEvaluation);
@@ -163,15 +145,15 @@ export async function evaluateFeature(deps: Dependencies, options: EvaluateOptio
 
   if (feature?.variations) {
     if (options.verbose) {
-      printLogs(variationEvaluationLogs);
+      printDiagnostics(variationEvaluationDiagnostics);
     }
 
-    console.log("Value:", JSON.stringify(variationEvaluation.variation?.value));
+    console.log(CLI_FORMAT_GREEN, `Value: ${JSON.stringify(variationEvaluation.variation?.value)}`);
     console.log("\nDetails:\n");
 
     printEvaluationDetails(variationEvaluation);
   } else {
-    console.log("No variations defined.");
+    console.log(CLI_FORMAT_YELLOW, "No variations defined.");
   }
 
   // variables
@@ -180,15 +162,14 @@ export async function evaluateFeature(deps: Dependencies, options: EvaluateOptio
       printHeader(`Variable: ${key}`);
 
       if (options.verbose) {
-        printLogs(variableEvaluationLogs[key]);
+        printDiagnostics(variableEvaluationDiagnostics[key]);
       }
 
-      console.log(
-        "Value:",
+      const variableValue =
         typeof value.variableValue !== "undefined"
           ? JSON.stringify(value.variableValue)
-          : value.variableValue,
-      );
+          : value.variableValue;
+      console.log(CLI_FORMAT_GREEN, `Value: ${variableValue}`);
       console.log("\nDetails:\n");
 
       printEvaluationDetails(value);
@@ -196,30 +177,61 @@ export async function evaluateFeature(deps: Dependencies, options: EvaluateOptio
   } else {
     printHeader("Variables");
 
-    console.log("No variables defined.");
+    console.log(CLI_FORMAT_YELLOW, "No variables defined.");
+  }
+
+  return allEvaluations;
+}
+
+export async function evaluateFeature(deps: Dependencies, options: EvaluateOptions) {
+  const datafiles = await buildRuntimeDatafiles(deps, {
+    environment: options.environment || false,
+    target: options.target,
+    revision: "include-all-features",
+    inflate: options.inflate,
+  });
+
+  const results = [];
+  for (const entry of datafiles) {
+    const evaluations = await evaluateFeatureWithDatafile(entry.datafile, options, entry.target);
+    results.push({ target: entry.target, evaluations });
+  }
+
+  if (options.json) {
+    const output = results.length === 1 ? results[0].evaluations : results;
+    console.log(options.pretty ? JSON.stringify(output, null, 2) : JSON.stringify(output));
   }
 }
 
 export const evaluatePlugin: Plugin = {
   command: "evaluate",
   handler: async ({ rootDirectoryPath, projectConfig, datasource, parsed }) => {
-    await evaluateFeature(
-      {
-        rootDirectoryPath,
-        projectConfig,
-        datasource,
-        options: parsed,
-      },
-      {
-        environment: parsed.environment,
-        feature: parsed.feature,
-        context: parsed.context ? JSON.parse(parsed.context) : {},
-        // @NOTE: introduce optional --at?
-        json: parsed.json,
-        pretty: parsed.pretty,
-        verbose: parsed.verbose,
-      },
-    );
+    assertProjectSetJsonSelection(projectConfig, parsed.set, parsed.json);
+
+    const executions = await getProjectSetExecutions(projectConfig, datasource, parsed.set);
+
+    for (const execution of executions) {
+      printSetHeader(projectConfig, execution.set, parsed.json);
+
+      await evaluateFeature(
+        {
+          rootDirectoryPath,
+          projectConfig: execution.projectConfig,
+          datasource: execution.datasource,
+          options: parsed,
+        },
+        {
+          environment: parsed.environment,
+          feature: parsed.feature,
+          context: parsed.context ? JSON.parse(parsed.context) : {},
+          // @NOTE: introduce optional --at?
+          json: parsed.json,
+          pretty: parsed.pretty,
+          verbose: parsed.verbose,
+          target: parsed.target,
+        },
+      );
+    }
   },
   examples: [
     {

package/src/find-duplicate-segments/index.ts

@@ -1,6 +1,14 @@
 import { findDuplicateSegments, DuplicateSegmentsOptions } from "./findDuplicateSegments";
 import { Dependencies } from "../dependencies";
 import { Plugin } from "../cli";
+import { getProjectSetExecutions, printSetHeader } from "../sets";
+import {
+  CLI_COLOR_CYAN,
+  CLI_FORMAT_BOLD,
+  CLI_FORMAT_GREEN,
+  CLI_FORMAT_YELLOW,
+  colorize,
+} from "../tester/cliFormat";
 
 export async function findDuplicateSegmentsInProject(
   deps: Dependencies,
@@ -9,21 +17,25 @@ export async function findDuplicateSegmentsInProject(
   const duplicates = await findDuplicateSegments(deps, options);
 
   console.log("");
+  console.log(CLI_FORMAT_BOLD, "Finding duplicate Featurevisor segments");
 
   if (duplicates.length === 0) {
-    console.log("No duplicate segments found");
+    console.log(CLI_FORMAT_GREEN, "No duplicate segments found");
     return;
   }
 
-  console.log(`Found ${duplicates.length} duplicate(s):\n`);
+  console.log(CLI_FORMAT_YELLOW, `Found ${duplicates.length} duplicate(s):`);
+  console.log("");
 
   duplicates.forEach((entry) => {
     if (options.authors) {
-      console.log(`  - Segments: ${entry.segments.join(", ")}`);
-      console.log(`    Authors:  ${entry.authors && entry.authors.join(", ")}`);
+      console.log(`  ${colorize("•", CLI_COLOR_CYAN)} Segments: ${entry.segments.join(", ")}`);
+      console.log(
+        `    ${colorize("Authors", CLI_COLOR_CYAN)}:  ${entry.authors && entry.authors.join(", ")}`,
+      );
       console.log("");
     } else {
-      console.log(`  - ${entry.segments.join(", ")}`);
+      console.log(`  ${colorize("•", CLI_COLOR_CYAN)} ${entry.segments.join(", ")}`);
     }
   });
 }
@@ -31,17 +43,23 @@ export async function findDuplicateSegmentsInProject(
 export const findDuplicateSegmentsPlugin: Plugin = {
   command: "find-duplicate-segments",
   handler: async ({ rootDirectoryPath, projectConfig, datasource, parsed }) => {
-    await findDuplicateSegmentsInProject(
-      {
-        rootDirectoryPath,
-        projectConfig,
-        datasource,
-        options: parsed,
-      },
-      {
-        authors: parsed.authors,
-      },
-    );
+    const executions = await getProjectSetExecutions(projectConfig, datasource, parsed.set);
+
+    for (const execution of executions) {
+      printSetHeader(projectConfig, execution.set);
+
+      await findDuplicateSegmentsInProject(
+        {
+          rootDirectoryPath,
+          projectConfig: execution.projectConfig,
+          datasource: execution.datasource,
+          options: parsed,
+        },
+        {
+          authors: parsed.authors,
+        },
+      );
+    }
   },
   examples: [
     {

package/src/find-usage/index.ts

@@ -6,6 +6,15 @@ import {
   extractAttributeKeysFromConditions,
   extractSegmentKeysFromGroupSegments,
 } from "../utils/extractKeys";
+import { getProjectSetExecutions, printSetHeader } from "../sets";
+import {
+  CLI_COLOR_CYAN,
+  CLI_COLOR_DIM,
+  CLI_FORMAT_BOLD,
+  CLI_FORMAT_GREEN,
+  CLI_FORMAT_YELLOW,
+  colorize,
+} from "../tester/cliFormat";
 
 export interface UsageInFeatures {
   [featureKey: string]: {
@@ -110,7 +119,7 @@ export async function findAllUsageInFeatures(deps: Dependencies): Promise<UsageI
     }
 
     // no environments
-    if (projectConfig.environments === false) {
+    if (!Array.isArray(projectConfig.environments)) {
       // force
       if (Array.isArray(feature.force)) {
         feature.force.forEach((force) => {
@@ -301,6 +310,8 @@ export interface FindUsageOptions {
 export async function findUsageInProject(deps: Dependencies, options: FindUsageOptions) {
   const { datasource } = deps;
 
+  console.log("");
+  console.log(CLI_FORMAT_BOLD, "Finding Featurevisor usage");
   console.log("");
 
   const usageInFeatures = await findAllUsageInFeatures(deps);
@@ -311,18 +322,21 @@ export async function findUsageInProject(deps: Dependencies, options: FindUsageO
     const usedInFeatures = await findFeatureUsage(usageInFeatures, options.feature);
 
     if (usedInFeatures.size === 0) {
-      console.log(`Feature "${options.feature}" is not used in any features.`);
+      console.log(CLI_FORMAT_GREEN, `Feature "${options.feature}" is not used in any features.`);
     } else {
-      console.log(`Feature "${options.feature}" is used in the following features:\n`);
+      console.log(CLI_FORMAT_BOLD, `Feature "${options.feature}" is used in these features`);
+      console.log("");
 
       for (const featureKey of Array.from(usedInFeatures)) {
         if (options.authors) {
           const entries = await datasource.listHistoryEntries("feature", featureKey);
           const authors = Array.from(new Set(entries.map((entry) => entry.author)));
 
-          console.log(`  - ${featureKey} (Authors: ${authors.join(", ")})`);
+          console.log(
+            `  ${colorize("•", CLI_COLOR_CYAN)} ${featureKey} ${colorize(`(Authors: ${authors.join(", ")})`, CLI_COLOR_DIM)}`,
+          );
         } else {
-          console.log(`  - ${featureKey}`);
+          console.log(`  ${colorize("•", CLI_COLOR_CYAN)} ${featureKey}`);
         }
       }
     }
@@ -335,18 +349,21 @@ export async function findUsageInProject(deps: Dependencies, options: FindUsageO
     const usedInFeatures = await findSegmentUsage(usageInFeatures, options.segment);
 
     if (usedInFeatures.size === 0) {
-      console.log(`Segment "${options.segment}" is not used in any features.`);
+      console.log(CLI_FORMAT_GREEN, `Segment "${options.segment}" is not used in any features.`);
     } else {
-      console.log(`Segment "${options.segment}" is used in the following features:\n`);
+      console.log(CLI_FORMAT_BOLD, `Segment "${options.segment}" is used in these features`);
+      console.log("");
 
       for (const featureKey of Array.from(usedInFeatures)) {
         if (options.authors) {
           const entries = await datasource.listHistoryEntries("feature", featureKey);
           const authors = Array.from(new Set(entries.map((entry) => entry.author)));
 
-          console.log(`  - ${featureKey} (Authors: ${authors.join(", ")})`);
+          console.log(
+            `  ${colorize("•", CLI_COLOR_CYAN)} ${featureKey} ${colorize(`(Authors: ${authors.join(", ")})`, CLI_COLOR_DIM)}`,
+          );
         } else {
-          console.log(`  - ${featureKey}`);
+          console.log(`  ${colorize("•", CLI_COLOR_CYAN)} ${featureKey}`);
         }
       }
     }
@@ -359,22 +376,28 @@ export async function findUsageInProject(deps: Dependencies, options: FindUsageO
     const usedIn = await findAttributeUsage(usageInFeatures, usageInSegments, options.attribute);
 
     if (usedIn.features.size === 0 && usedIn.segments.size === 0) {
-      console.log(`Attribute "${options.attribute}" is not used in any features or segments.`);
+      console.log(
+        CLI_FORMAT_GREEN,
+        `Attribute "${options.attribute}" is not used in any features or segments.`,
+      );
 
       return;
     }
 
     if (usedIn.segments.size > 0) {
-      console.log(`Attribute "${options.attribute}" is used in the following segments:\n`);
+      console.log(CLI_FORMAT_BOLD, `Attribute "${options.attribute}" is used in these segments`);
+      console.log("");
 
       for (const segmentKey of Array.from(usedIn.segments)) {
         if (options.authors) {
           const entries = await datasource.listHistoryEntries("segment", segmentKey);
           const authors = Array.from(new Set(entries.map((entry) => entry.author)));
 
-          console.log(`  - ${segmentKey} (Authors: ${authors.join(", ")})`);
+          console.log(
+            `  ${colorize("•", CLI_COLOR_CYAN)} ${segmentKey} ${colorize(`(Authors: ${authors.join(", ")})`, CLI_COLOR_DIM)}`,
+          );
         } else {
-          console.log(`  - ${segmentKey}`);
+          console.log(`  ${colorize("•", CLI_COLOR_CYAN)} ${segmentKey}`);
         }
       }
 
@@ -387,16 +410,20 @@ export async function findUsageInProject(deps: Dependencies, options: FindUsageO
       }
 
       if (affectedFeatures.size > 0) {
-        console.log(`\nSegments above are used in the following features:\n`);
+        console.log("");
+        console.log(CLI_FORMAT_BOLD, "Segments above are used in these features");
+        console.log("");
 
         for (const featureKey of Array.from(affectedFeatures)) {
           if (options.authors) {
             const entries = await datasource.listHistoryEntries("feature", featureKey);
             const authors = Array.from(new Set(entries.map((entry) => entry.author)));
 
-            console.log(`  - ${featureKey} (Authors: ${authors.join(", ")})`);
+            console.log(
+              `  ${colorize("•", CLI_COLOR_CYAN)} ${featureKey} ${colorize(`(Authors: ${authors.join(", ")})`, CLI_COLOR_DIM)}`,
+            );
           } else {
-            console.log(`  - ${featureKey}`);
+            console.log(`  ${colorize("•", CLI_COLOR_CYAN)} ${featureKey}`);
           }
         }
 
@@ -405,16 +432,22 @@ export async function findUsageInProject(deps: Dependencies, options: FindUsageO
     }
 
     if (usedIn.features.size > 0) {
-      console.log(`Attribute "${options.attribute}" is used directly in the following features:\n`);
+      console.log(
+        CLI_FORMAT_BOLD,
+        `Attribute "${options.attribute}" is used directly in these features`,
+      );
+      console.log("");
 
       for (const featureKey of Array.from(usedIn.features)) {
         if (options.authors) {
           const entries = await datasource.listHistoryEntries("feature", featureKey);
           const authors = Array.from(new Set(entries.map((entry) => entry.author)));
 
-          console.log(`  - ${featureKey} (Authors: ${authors.join(", ")})`);
+          console.log(
+            `  ${colorize("•", CLI_COLOR_CYAN)} ${featureKey} ${colorize(`(Authors: ${authors.join(", ")})`, CLI_COLOR_DIM)}`,
+          );
         } else {
-          console.log(`  - ${featureKey}`);
+          console.log(`  ${colorize("•", CLI_COLOR_CYAN)} ${featureKey}`);
         }
       }
 
@@ -429,18 +462,21 @@ export async function findUsageInProject(deps: Dependencies, options: FindUsageO
     const unusedSegments = await findUnusedSegments(deps, usageInFeatures);
 
     if (unusedSegments.size === 0) {
-      console.log("No unused segments found.");
+      console.log(CLI_FORMAT_GREEN, "No unused segments found.");
     } else {
-      console.log("Unused segments:\n");
+      console.log(CLI_FORMAT_YELLOW, "Unused segments");
+      console.log("");
 
       for (const segmentKey of Array.from(unusedSegments)) {
         if (options.authors) {
           const entries = await datasource.listHistoryEntries("segment", segmentKey);
           const authors = Array.from(new Set(entries.map((entry) => entry.author)));
 
-          console.log(`  - ${segmentKey} (Authors: ${authors.join(", ")})`);
+          console.log(
+            `  ${colorize("•", CLI_COLOR_CYAN)} ${segmentKey} ${colorize(`(Authors: ${authors.join(", ")})`, CLI_COLOR_DIM)}`,
+          );
         } else {
-          console.log(`  - ${segmentKey}`);
+          console.log(`  ${colorize("•", CLI_COLOR_CYAN)} ${segmentKey}`);
         }
       }
     }
@@ -453,18 +489,21 @@ export async function findUsageInProject(deps: Dependencies, options: FindUsageO
     const unusedAttributes = await findUnusedAttributes(deps, usageInFeatures, usageInSegments);
 
     if (unusedAttributes.size === 0) {
-      console.log("No unused attributes found.");
+      console.log(CLI_FORMAT_GREEN, "No unused attributes found.");
     } else {
-      console.log("Unused attributes:\n");
+      console.log(CLI_FORMAT_YELLOW, "Unused attributes");
+      console.log("");
 
       for (const attributeKey of Array.from(unusedAttributes)) {
         if (options.authors) {
           const entries = await datasource.listHistoryEntries("attribute", attributeKey);
           const authors = Array.from(new Set(entries.map((entry) => entry.author)));
 
-          console.log(`  - ${attributeKey} (Authors: ${authors.join(", ")})`);
+          console.log(
+            `  ${colorize("•", CLI_COLOR_CYAN)} ${attributeKey} ${colorize(`(Authors: ${authors.join(", ")})`, CLI_COLOR_DIM)}`,
+          );
         } else {
-          console.log(`  - ${attributeKey}`);
+          console.log(`  ${colorize("•", CLI_COLOR_CYAN)} ${attributeKey}`);
         }
       }
     }
@@ -472,28 +511,34 @@ export async function findUsageInProject(deps: Dependencies, options: FindUsageO
     return;
   }
 
-  console.log("Please specify a segment or attribute.");
+  console.log(CLI_FORMAT_YELLOW, "Please specify a feature, segment, attribute, or unused query.");
 }
 
 export const findUsagePlugin: Plugin = {
   command: "find-usage",
   handler: async ({ rootDirectoryPath, projectConfig, datasource, parsed }) => {
-    await findUsageInProject(
-      {
-        rootDirectoryPath,
-        projectConfig,
-        datasource,
-        options: parsed,
-      },
-      {
-        feature: parsed.feature,
-        segment: parsed.segment,
-        attribute: parsed.attribute,
-        unusedSegments: parsed.unusedSegments,
-        unusedAttributes: parsed.unusedAttributes,
-        authors: parsed.authors,
-      },
-    );
+    const executions = await getProjectSetExecutions(projectConfig, datasource, parsed.set);
+
+    for (const execution of executions) {
+      printSetHeader(projectConfig, execution.set);
+
+      await findUsageInProject(
+        {
+          rootDirectoryPath,
+          projectConfig: execution.projectConfig,
+          datasource: execution.datasource,
+          options: parsed,
+        },
+        {
+          feature: parsed.feature,
+          segment: parsed.segment,
+          attribute: parsed.attribute,
+          unusedSegments: parsed.unusedSegments,
+          unusedAttributes: parsed.unusedAttributes,
+          authors: parsed.authors,
+        },
+      );
+    }
   },
   examples: [
     {