@ontrails/regrade 1.0.0-beta.41 → 1.0.0-beta.43

package/src/downstream/report.ts

@@ -6,6 +6,7 @@ import {
 } from '@ontrails/core';
 import type { ScanTargets } from '@ontrails/core';
 import type {
+  GovernedVocabularyHistoryProvenance,
   WardenDiagnostic,
   WardenFixEdit,
   WardenGuidance,
@@ -13,6 +14,7 @@ import type {
 } from '@ontrails/warden';
 import {
   getWardenRuleMetadata,
+  governedVocabularyHistoryProvenanceSchema,
   isWardenSourceScanTarget,
   loadProjectWardenRules,
   wardenRules,
@@ -756,7 +758,9 @@ export interface RegradeReport {
   };
   /** Saved applied Regrade history evidence for vocabulary regrades. */
   readonly history?: {
+    readonly id?: string;
     readonly path: string;
+    readonly provenance?: GovernedVocabularyHistoryProvenance;
     readonly schemaVersion: number;
     readonly status: 'applied' | 'checked' | 'replay';
   };
@@ -1464,7 +1468,14 @@ export const regradeReportOutput = z.object({
     ),
   history: z
     .object({
+      id: z
+        .string()
+        .optional()
+        .describe('Stable consolidated Regrade history identity'),
       path: z.string().describe('Root-relative applied history entry path'),
+      provenance: governedVocabularyHistoryProvenanceSchema
+        .optional()
+        .describe('Governed transition evidence attached to the applied run'),
       schemaVersion: z.number().describe('Regrade history schema version'),
       status: z
         .enum(['applied', 'checked', 'replay'])
@@ -1522,7 +1533,7 @@ export const regradeReportOutput = z.object({
 /**
  * Built-in regrade classes available to the report trail.
  *
- * Warden owns term detection and fix metadata. Regrade projects Warden rules
+ * Warden owns term detection and fix metadata. Regrade derives Warden rules
  * that advertise `term-rewrite` capability into reportable classes and then
  * owns application/reporting of the resulting rewrite or review outcomes.
  */

package/src/downstream/vocabulary-registry.ts

@@ -31,12 +31,25 @@ const scopeFromTransition = (
     return undefined;
   }
   return {
-    ...(scope.exclude === undefined ? {} : { exclude: scope.exclude }),
-    ...(scope.extensions === undefined ? {} : { extensions: scope.extensions }),
+    ...(scope.exclude === undefined ? {} : { exclude: [...scope.exclude] }),
+    ...(scope.extensions === undefined
+      ? {}
+      : { extensions: [...scope.extensions] }),
     ...(scope.ignoredDirectories === undefined
       ? {}
-      : { ignoredDirectories: scope.ignoredDirectories }),
-    ...(scope.include === undefined ? {} : { include: scope.include }),
+      : { ignoredDirectories: [...scope.ignoredDirectories] }),
+    ...(scope.include === undefined ? {} : { include: [...scope.include] }),
+    ...(scope.policyClassified === undefined
+      ? {}
+      : {
+          policyClassified: scope.policyClassified.map((policy) => ({
+            ...policy,
+            paths: [...policy.paths],
+          })),
+        }),
+    ...(scope.teachingSurfaces === undefined
+      ? {}
+      : { teachingSurfaces: [...scope.teachingSurfaces] }),
   };
 };
 
@@ -53,37 +66,122 @@ const defaultFormsAreRegistrySafe = (
   });
 };
 
+const classifiedTargetMatches = (
+  transition: GovernedVocabularyTransition,
+  to: string
+): boolean =>
+  transition.target.kind === 'classified' &&
+  transition.target.options.some((option) => option.to === to);
+
+const uniqueForms = (forms: readonly string[]): readonly string[] => [
+  ...new Set(forms),
+];
+
 export const vocabularyRegradePlanFromTransition = (
-  transition: GovernedVocabularyTransition
+  transition: GovernedVocabularyTransition,
+  classifiedTarget?: string
 ): VocabularyRegradePlan | null => {
+  const isClassifiedPlan =
+    classifiedTarget !== undefined &&
+    classifiedTargetMatches(transition, classifiedTarget);
+  if (transition.target.kind === 'classified' && !isClassifiedPlan) {
+    return null;
+  }
   if (
-    transition.target.kind !== 'single' ||
+    transition.target.kind === 'single' &&
     !defaultFormsAreRegistrySafe(transition)
   ) {
     return null;
   }
 
   const scope = scopeFromTransition(transition);
+  const to =
+    transition.target.kind === 'single'
+      ? transition.target.to
+      : classifiedTarget;
+  if (to === undefined) {
+    return null;
+  }
   return {
     caseSensitive: true,
-    deferForms: transition.reviewForms,
+    deferForms: isClassifiedPlan
+      ? uniqueForms([...transition.oldForms, ...transition.reviewForms])
+      : transition.reviewForms,
+    ...(transition.fileRenames.length === 0
+      ? {}
+      : {
+          fileRenames: transition.fileRenames.map((rename) => ({ ...rename })),
+        }),
     from: transition.from,
     id: transition.id,
     intent: transition.intent,
     kind: 'vocabulary',
-    overrides: transition.safeRewriteForms,
+    ...(isClassifiedPlan ? {} : { overrides: transition.safeRewriteForms }),
     preserve: preserveRulesFromTransition(transition),
     ...(scope === undefined ? {} : { scope }),
-    to: transition.target.to,
+    to,
   };
 };
 
+export const vocabularyRegradePlanForInput = (
+  from: string,
+  to: string
+): VocabularyRegradePlan | null => {
+  const transition = listGovernedVocabularyTransitions().find(
+    (candidate) => candidate.from === from
+  );
+  if (transition === undefined) {
+    return null;
+  }
+  if (transition.target.kind === 'single' && transition.target.to !== to) {
+    return null;
+  }
+  return vocabularyRegradePlanFromTransition(transition, to);
+};
+
 export const listVocabularyRegradePlansFromRegistry =
   (): readonly VocabularyRegradePlan[] =>
     listGovernedVocabularyTransitions()
-      .map(vocabularyRegradePlanFromTransition)
+      .map((transition) => vocabularyRegradePlanFromTransition(transition))
       .filter((plan): plan is VocabularyRegradePlan => plan !== null);
 
+/**
+ * Derive conservative current-tree audit plans for every single-target
+ * governed transition. Transitions that are unsafe to rewrite mechanically
+ * still participate with every known form deferred to review.
+ */
+export const listVocabularyRegradeAuditPlansFromRegistry =
+  (): readonly VocabularyRegradePlan[] =>
+    listGovernedVocabularyTransitions().flatMap((transition) => {
+      if (
+        transition.status === 'planned' ||
+        transition.target.kind !== 'single'
+      ) {
+        return [];
+      }
+      const runnable = vocabularyRegradePlanFromTransition(transition);
+      if (runnable !== null) {
+        return [runnable];
+      }
+      const scope = scopeFromTransition(transition);
+      return [
+        {
+          caseSensitive: true,
+          deferForms: uniqueForms([
+            ...transition.oldForms,
+            ...transition.reviewForms,
+          ]),
+          from: transition.from,
+          id: transition.id,
+          intent: transition.intent,
+          kind: 'vocabulary' as const,
+          preserve: preserveRulesFromTransition(transition),
+          ...(scope === undefined ? {} : { scope }),
+          to: transition.target.to,
+        },
+      ];
+    });
+
 export const vocabularyRegradeTransitionForInput = (
   from: string,
   to: string
@@ -91,6 +189,7 @@ export const vocabularyRegradeTransitionForInput = (
   listGovernedVocabularyTransitions().find(
     (transition) =>
       transition.from === from &&
-      transition.target.kind === 'single' &&
-      transition.target.to === to
+      (transition.target.kind === 'single'
+        ? transition.target.to === to
+        : transition.target.options.some((option) => option.to === to))
   );