filegrc 0.16.1 → 0.16.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "filegrc",
-  "version": "0.16.1",
+  "version": "0.16.2",
   "description": "Zero-dependency Git-native GRC engine",
   "license": "MIT",
   "repository": {

package/src/cli.js

@@ -1846,7 +1846,11 @@ function buildProgramPathResult(model, readiness, auditReadiness) {
       nextActions: (current?.items || []).filter((item) => item.status === "action")
     };
   });
-  const currentStep = stages.find((stage) => !["complete", "operating", "management-ready"].includes(stage.status)) || stages.at(-1);
+  const recommendedStage = readiness.stages.find((stage) => stage.items.includes(readiness.firstAction));
+  const recommendedId = recommendedStage?.id === "operation" ? "run" : recommendedStage?.id;
+  const currentStep = stages.find(({ id }) => id === recommendedId)
+    || stages.find((stage) => !["complete", "operating", "management-ready"].includes(stage.status))
+    || stages.at(-1);
   return {
     schemaVersion: 1,
     dataModelVersion: String(model.modelVersion),

package/src/collection-scope.js

@@ -65,6 +65,24 @@ export function scopedCollectionRecords(loaded, resourceType, program) {
   ));
 }
 
+// These records can change which members enter a collection even when they
+// are not part of its current revision inputs yet.
+const COLLECTION_MEMBERSHIP_SOURCES = {
+  person: ["workspace", "program", "appointment", "team", "system", "component", "vendor", "control", "policy", "document", "obligation"],
+  vendor: ["program", "system", "component", "audit"],
+  component: ["program", "system", "control"],
+  "complementary-control": ["program", "system", "component", "control"],
+  "information-type": ["program", "system", "component", "vendor"],
+  "retention-schedule-item": ["program", "system", "component", "vendor", "control", "information-type", "source-coverage"],
+  framework: ["program"],
+  system: ["program"],
+  control: ["program"]
+};
+
+export function collectionMembershipSourceTypes(resourceType) {
+  return COLLECTION_MEMBERSHIP_SOURCES[resourceType] || [];
+}
+
 export function retentionScheduleReviewScope(loaded) {
   const programs = loaded.resources.filter((record) => (
     record.type === "program" && record.status !== "retired"

package/src/program-readiness.js

@@ -3,6 +3,7 @@ import { modelSupports } from "../model/index.js";
 import { applicabilityReviewIsCurrent } from "./applicability-scope.js";
 import { assessRequiredAppointments } from "./appointments.js";
 import { assessCollectionReviews } from "./collection-review.js";
+import { collectionMembershipSourceTypes, collectionRevisionInputs, collectionScopeRevisionFacts } from "./collection-scope.js";
 import { openPlaceholderCount, substantiveMarkdown } from "./content-readiness.js";
 import { coverageEnd, coverageStart } from "./coverage.js";
 import { planObligations } from "./obligations.js";
@@ -233,6 +234,7 @@ export async function assessProgramReadiness(input, options = {}) {
     policyStage,
     controlStage
   ];
+  const prioritizedSetupItems = prioritizeReviewDependencies(evidenceGateStages, loaded, program);
   for (const current of evidenceGateStages) finalizeStage(current);
   const evidenceReady = evidenceGateStages.every((current) => current.counts.action === 0);
   const stages = [
@@ -260,7 +262,8 @@ export async function assessProgramReadiness(input, options = {}) {
   const items = stages.flatMap((current) => current.items);
   const managedItems = items.filter((current) => !["info", "later"].includes(current.status));
   const complete = managedItems.filter((current) => current.status === "complete").length;
-  const firstAction = items.find((current) => current.status === "action") || null;
+  const firstAction = [...prioritizedSetupItems, ...stages.at(-1).items]
+    .find((current) => current.status === "action") || null;
   const target = {
     programId: program?.id || null,
     goal: program?.assuranceGoal || "none",
@@ -1966,6 +1969,50 @@ function finalizeStage(current) {
   current.status = current.counts.action ? "action" : current.counts.later ? "later" : "complete";
 }
 
+// A collection confirmation can be performed early, but an unfinished input
+// would make it stale again. Derive the ordering from the same revision inputs
+// used to decide whether that confirmation is current.
+export function prioritizeReviewDependencies(stages, loaded, program) {
+  const items = stages.flatMap(({ items }) => items);
+  const edges = new Map(items.map((_, index) => [index, new Set()]));
+  const indegree = items.map(() => 0);
+  for (const [reviewIndex, review] of items.entries()) {
+    if (review.status !== "action" || !review.id.startsWith("collection-review-")) continue;
+    const resourceType = review.id.slice("collection-review-".length);
+    if (!loaded.model.collectionReviews?.[resourceType]) continue;
+    const inputTypes = new Set(collectionRevisionInputs(loaded, resourceType, program)
+      .map(({ record }) => record.type));
+    for (const type of collectionMembershipSourceTypes(resourceType)) inputTypes.add(type);
+    const scopeFacts = collectionScopeRevisionFacts(loaded, resourceType, program);
+    if (Object.keys(scopeFacts).some((key) => key !== "programId")) inputTypes.add("program");
+    for (const key of Object.keys(scopeFacts)) {
+      if (!key.endsWith("Ids")) continue;
+      const type = key.slice(0, -3).replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+      if (loaded.model.resources?.[type]) inputTypes.add(type);
+    }
+    for (const [sourceIndex, source] of items.entries()) {
+      if (sourceIndex === reviewIndex || source.status !== "action"
+        || source.id.startsWith("collection-review-")
+        || !inputTypes.has(source.resourceType)) continue;
+      edges.get(sourceIndex).add(reviewIndex);
+      indegree[reviewIndex]++;
+    }
+  }
+  const remaining = new Set(items.map((_, index) => index));
+  const ordered = [];
+  while (remaining.size) {
+    const next = [...remaining].find((index) => indegree[index] === 0);
+    if (next === undefined) break;
+    remaining.delete(next);
+    ordered.push(items[next]);
+    for (const dependent of edges.get(next)) indegree[dependent]--;
+  }
+  if (ordered.length !== items.length) return items;
+  const rank = new Map(ordered.map((item, index) => [item, index]));
+  for (const stage of stages) stage.items.sort((left, right) => rank.get(left) - rank.get(right));
+  return ordered;
+}
+
 function item(id, status, title, message, resource = {}, details = {}) {
   return {
     id,

package/src/web.js

@@ -589,6 +589,13 @@ function readinessOverview() {
 }
 
 function nextProgramStageHref() {
+  const firstAction = state.programReadiness?.firstAction;
+  const recommendedStage = state.programReadiness?.stages?.find((stage) => stage.items.some((item) => (
+    item.id === firstAction?.id && item.resourceId === firstAction?.resourceId
+  )));
+  if (recommendedStage) {
+    return "#/stage/" + encodeURIComponent(recommendedStage.id === "operation" ? "run" : recommendedStage.id);
+  }
   const nextStage = READINESS_STAGES.find((stage) => {
     const progress = stageProgress(stage);
     return progress.complete < progress.total;