@habitat-ai/service 0.2.4 → 0.3.1

package/dist/service/modules/catalog/router/catalog.router.js

@@ -599,21 +599,22 @@ const check = module.check.effect(function* ({ context, input }) {
             };
         }
     }
-    const reports = [];
-    for (const prepared of preparations) {
+    const reports = new Array(preparations.length);
+    const readyGritEvaluations = [];
+    for (const [applicationIndex, prepared] of preparations.entries()) {
         if (prepared.kind === "structure") {
             if (prepared.preparation.kind === "failed") {
-                reports.push(prepared.preparation.report);
+                reports[applicationIndex] = prepared.preparation.report;
                 continue;
             }
             const admitted = prepared.preparation.value;
             const application = admitted.application;
             if (admitted.scopes.length === 0) {
-                reports.push(evaluatedStructureApplication(application, []));
+                reports[applicationIndex] = evaluatedStructureApplication(application, []);
                 continue;
             }
             if (inventoryPreparation.kind === "failed") {
-                reports.push(failedStructureApplication(application, "InventoryFailed", inventoryPreparation.detail));
+                reports[applicationIndex] = failedStructureApplication(application, "InventoryFailed", inventoryPreparation.detail);
                 continue;
             }
             if (inventoryPreparation.kind === "not-required") {
@@ -627,50 +628,87 @@ const check = module.check.effect(function* ({ context, input }) {
                 return yield* prepareStructureObservations(structureChildObservationPaths(plan, roots.kinds), roots.kinds);
             });
             if (observations.kind === "failed") {
-                reports.push(failedStructureApplication(application, "StructureObservationFailed", observations.detail));
+                reports[applicationIndex] = failedStructureApplication(application, "StructureObservationFailed", observations.detail);
                 continue;
             }
-            reports.push(evaluatedStructureApplication(application, evaluateStructurePlan(plan, observations.kinds)));
+            reports[applicationIndex] = evaluatedStructureApplication(application, evaluateStructurePlan(plan, observations.kinds));
             continue;
         }
         const application = prepared.application;
         const patternAttempt = yield* Effect.result(context.fileSystem.readFileString(application.runner.pattern.absolutePath));
         if (patternAttempt._tag === "Failure") {
-            reports.push(failedApplication(application, "PatternReadFailed", `Unable to read pattern asset "${application.runner.pattern.relativePath}".`));
+            reports[applicationIndex] = failedApplication(application, "PatternReadFailed", `Unable to read pattern asset "${application.runner.pattern.relativePath}".`);
             continue;
         }
         const program = extractGritProgram(patternAttempt.success);
         if (!program.ok) {
-            reports.push(failedApplication(application, "PatternInvalid", program.detail));
+            reports[applicationIndex] = failedApplication(application, "PatternInvalid", program.detail);
             continue;
         }
         const subjectPreparation = yield* prepareGritSubjects(application, context.workspaceRoot, context.fileSystem, context.path);
         if (subjectPreparation.kind === "failed") {
-            reports.push(failedApplication(application, "SetupFailed", subjectPreparation.detail));
+            reports[applicationIndex] = failedApplication(application, "SetupFailed", subjectPreparation.detail);
             continue;
         }
         if (subjectPreparation.kind === "not-applicable") {
             if (!isCompatibilityRule(application)) {
                 return yield* Effect.die(new Error("Version-three Grit applications cannot be not applicable."));
             }
-            reports.push(notApplicableApplication(application));
+            reports[applicationIndex] = notApplicableApplication(application);
             continue;
         }
         const subjects = subjectPreparation.subjects;
-        const evaluation = yield* Effect.result(context.ruleEvaluation.evaluate({
+        readyGritEvaluations.push({
+            applicationIndex,
+            application,
+            programId: `application-${applicationIndex}`,
             program: program.program,
+            subjects,
             subjectPaths: subjects.map((subject) => subject.absolutePath),
+        });
+    }
+    for (const evaluations of groupGritEvaluations(readyGritEvaluations)) {
+        const first = evaluations[0];
+        if (first === undefined) {
+            return yield* Effect.die(new Error("A Grit evaluation group must not be empty."));
+        }
+        const evaluation = yield* Effect.result(context.ruleEvaluation.evaluate({
+            programs: evaluations.map(({ programId, program }) => ({ id: programId, program })),
+            subjectPaths: first.subjectPaths,
         }));
         if (evaluation._tag === "Failure") {
-            reports.push(failedApplication(application, evaluation.failure.reason, evaluation.failure.detail));
+            for (const prepared of evaluations) {
+                reports[prepared.applicationIndex] = failedApplication(prepared.application, evaluation.failure.reason, evaluation.failure.detail);
+            }
             continue;
         }
-        const normalized = normalizeFindings(evaluation.success.findings, subjects, context.workspaceRoot, context.path);
-        reports.push(normalized.ok
-            ? evaluatedApplication(application, normalized.findings)
-            : failedApplication(application, "FindingPathInvalid", normalized.detail));
+        const resultMismatch = evaluationResultMismatch(evaluations, evaluation.success.results);
+        if (resultMismatch !== undefined) {
+            for (const prepared of evaluations) {
+                reports[prepared.applicationIndex] = failedApplication(prepared.application, "InvalidOutput", resultMismatch);
+            }
+            continue;
+        }
+        const results = indexEvaluationResults(evaluation.success.results);
+        for (const prepared of evaluations) {
+            const result = results.get(prepared.programId);
+            if (result === undefined) {
+                return yield* Effect.die(new Error(`Validated evaluation result '${prepared.programId}' is absent.`));
+            }
+            const normalized = normalizeFindings(result.findings, prepared.subjects, context.workspaceRoot, context.path);
+            reports[prepared.applicationIndex] = normalized.ok
+                ? evaluatedApplication(prepared.application, normalized.findings)
+                : failedApplication(prepared.application, "FindingPathInvalid", normalized.detail);
+        }
+    }
+    const completedReports = [];
+    for (const [applicationIndex, report] of reports.entries()) {
+        if (report === undefined) {
+            return yield* Effect.die(new Error(`Habitat check produced no report for application ${applicationIndex}.`));
+        }
+        completedReports.push(report);
     }
-    return completedCheck(reports);
+    return completedCheck(completedReports);
 });
 /** Grouped catalog operation tree consumed by the module composition face. */
 export const catalog = { resolve, check };
@@ -707,6 +745,34 @@ function hasExactCauseCode(error, code) {
     const cause = "cause" in error.reason ? error.reason.cause : undefined;
     return typeof cause === "object" && cause !== null && "code" in cause && cause.code === code;
 }
+function groupGritEvaluations(evaluations) {
+    const groups = new Map();
+    for (const evaluation of evaluations) {
+        const key = JSON.stringify(evaluation.subjectPaths);
+        const group = groups.get(key);
+        if (group === undefined)
+            groups.set(key, [evaluation]);
+        else
+            group.push(evaluation);
+    }
+    return [...groups.values()];
+}
+function evaluationResultMismatch(evaluations, results) {
+    if (results.length !== evaluations.length) {
+        return `Rule evaluator returned ${results.length} program results for ${evaluations.length} requested programs.`;
+    }
+    const uniqueIds = new Set(results.map(({ programId }) => programId));
+    if (uniqueIds.size !== results.length) {
+        return "Rule evaluator returned duplicate program result identities.";
+    }
+    const unexpected = results.find((result, index) => result.programId !== evaluations[index]?.programId);
+    return unexpected === undefined
+        ? undefined
+        : "Rule evaluator did not preserve requested program result order and identity.";
+}
+function indexEvaluationResults(results) {
+    return new Map(results.map((result) => [result.programId, result]));
+}
 function prepareGritSubjects(application, workspaceRoot, fileSystem, path) {
     if (!isCompatibilityRule(application)) {
         return Effect.succeed({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@habitat-ai/service",
-  "version": "0.2.4",
+  "version": "0.3.1",
   "private": false,
   "repository": {
     "type": "git",
@@ -24,8 +24,8 @@
     "test": "bun test test"
   },
   "dependencies": {
-    "@habitat-ai/resource-rule-evaluation": "0.2.4",
-    "@habitat-ai/resource-source-inventory": "0.2.4",
+    "@habitat-ai/resource-rule-evaluation": "0.3.1",
+    "@habitat-ai/resource-source-inventory": "0.3.1",
     "@opentelemetry/api": "^1.9.0",
     "@orpc/contract": "2.0.0-beta.20",
     "@orpc/experimental-effect": "2.0.0-beta.20",