@akanjs/devkit 2.3.9-rc.0 → 2.3.9-rc.10

package/workflow/executor.ts

@@ -0,0 +1,590 @@
+import ts from "typescript";
+import type { AkanModuleContext } from "../akanContext";
+import type { Sys, Workspace } from "../commandDecorators";
+import { AppExecutor, LibExecutor } from "../executors";
+import { createWorkflowApplyReport, workflowCommandsForPlan } from "./artifacts";
+import { buildAkanModuleContextIndex } from "./moduleIndex";
+import {
+  insertionIndexForFieldOrder,
+  inspectConstantStructure,
+  inspectDictionaryStructure,
+  moduleComponentName,
+  moduleSourcePaths,
+  normalizeFieldType,
+} from "./source";
+import type {
+  PrimitiveChangedFile,
+  PrimitiveGeneratedFile,
+  PrimitiveNextAction,
+  PrimitiveWriteReport,
+  WorkflowApplyCommand,
+  WorkflowDiagnostic,
+  WorkflowInputValue,
+  WorkflowPlan,
+  WorkflowPostApplyCheck,
+  WorkflowPrimitiveOperations,
+  WorkflowRecommendation,
+  WorkflowStep,
+  WorkflowStepRegistry,
+  WorkflowStepResult,
+} from "./types";
+import { addFieldUiPolicyForType } from "./uiPolicy";
+
+export const workflowStepKey = (workflow: string, stepId: string) => `${workflow}:${stepId}`;
+
+export const primitiveReportToWorkflowStepResult = (report: PrimitiveWriteReport): WorkflowStepResult => ({
+  changedFiles: report.changedFiles,
+  generatedFiles: report.generatedFiles,
+  commands: report.validationCommands,
+  diagnostics: report.diagnostics,
+  recommendations: [],
+  nextActions: report.nextActions,
+});
+
+const workflowStringInput = (value: WorkflowInputValue | undefined) => (typeof value === "string" ? value : null);
+const workflowStringListInput = (value: WorkflowInputValue | undefined) =>
+  Array.isArray(value) ? value.join(",") : null;
+const workflowStringArrayInput = (value: WorkflowInputValue | undefined) => (Array.isArray(value) ? value : null);
+const workflowBooleanInput = (value: WorkflowInputValue | undefined) => (typeof value === "boolean" ? value : null);
+
+const postApplyDiagnostic = (code: string, message: string, target: string): WorkflowDiagnostic => ({
+  severity: "error",
+  code,
+  message,
+  failureScope: "source-change",
+  context: { target },
+});
+
+const postApplyWarning = (code: string, message: string, target: string): WorkflowDiagnostic => ({
+  severity: "warning",
+  code,
+  message,
+  failureScope: "source-change",
+  context: { target },
+});
+
+const sourceKindForPath = (filePath: string) => {
+  if (filePath.endsWith(".tsx")) return ts.ScriptKind.TSX;
+  if (filePath.endsWith(".ts")) return ts.ScriptKind.TS;
+  return null;
+};
+
+const checkPathCasing = async (workspace: Workspace, filePath: string) => {
+  const segments = filePath.split("/").filter(Boolean);
+  let current = ".";
+  for (const segment of segments) {
+    const entries = await workspace.readdir(current);
+    if (entries.includes(segment)) {
+      current = current === "." ? segment : `${current}/${segment}`;
+      continue;
+    }
+    const caseInsensitiveMatch = entries.find((entry) => entry.toLowerCase() === segment.toLowerCase());
+    return caseInsensitiveMatch
+      ? {
+          code: "workflow-path-casing-mismatch",
+          message: `Reported path segment "${segment}" does not match actual casing "${caseInsensitiveMatch}" in ${filePath}.`,
+        }
+      : {
+          code: "workflow-path-missing",
+          message: `Reported path does not exist: ${filePath}.`,
+        };
+  }
+  return null;
+};
+
+const checkTypeScriptSyntax = async (workspace: Workspace, filePath: string) => {
+  const scriptKind = sourceKindForPath(filePath);
+  if (!scriptKind) return null;
+  const content = await workspace.readFile(filePath);
+  const source = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true, scriptKind);
+  const diagnostic = ((source as ts.SourceFile & { parseDiagnostics?: readonly ts.DiagnosticWithLocation[] })
+    .parseDiagnostics ?? [])[0];
+  if (!diagnostic) return null;
+  const position = diagnostic.file?.getLineAndCharacterOfPosition(diagnostic.start ?? 0);
+  const location = position ? `:${position.line + 1}:${position.character + 1}` : "";
+  return {
+    code: "workflow-post-apply-syntax-error",
+    message: `Generated source has a TypeScript syntax error at ${filePath}${location}: ${ts.flattenDiagnosticMessageText(
+      diagnostic.messageText,
+      " ",
+    )}`,
+  };
+};
+
+const checkChangedFile = async (workspace: Workspace, file: PrimitiveChangedFile): Promise<WorkflowStepResult> => {
+  if (file.action === "remove") return { postApplyChecks: [] };
+  const diagnostics: WorkflowDiagnostic[] = [];
+  const checks: WorkflowPostApplyCheck[] = [];
+  const pathIssue = await checkPathCasing(workspace, file.path);
+  if (pathIssue) {
+    diagnostics.push(postApplyDiagnostic(pathIssue.code, pathIssue.message, file.path));
+    checks.push({ ...pathIssue, target: file.path, status: "failed" });
+    return { diagnostics, postApplyChecks: checks };
+  }
+  const syntaxIssue = await checkTypeScriptSyntax(workspace, file.path);
+  if (syntaxIssue) {
+    diagnostics.push(postApplyDiagnostic(syntaxIssue.code, syntaxIssue.message, file.path));
+    checks.push({ ...syntaxIssue, target: file.path, status: "failed" });
+    return { diagnostics, postApplyChecks: checks };
+  }
+  checks.push({
+    code: "workflow-post-apply-file-valid",
+    target: file.path,
+    status: "passed",
+    message: "Changed file exists with exact casing and parses as source when applicable.",
+  });
+  return { postApplyChecks: checks };
+};
+
+const checkRecommendationPath = async (
+  workspace: Workspace,
+  recommendation: WorkflowRecommendation,
+): Promise<WorkflowDiagnostic | null> => {
+  if (!recommendation.target || recommendation.target.includes("*") || recommendation.target.startsWith("<"))
+    return null;
+  const pathIssue = await checkPathCasing(workspace, recommendation.target);
+  if (!pathIssue) return null;
+  return {
+    severity: "warning",
+    code: "workflow-recommendation-path-unverified",
+    message: `${pathIssue.message} Recommendation "${recommendation.code}" should not be treated as an exact file target until the path is corrected.`,
+    failureScope: "source-change",
+    context: { target: recommendation.target },
+  };
+};
+
+const sourceChangeError = (diagnostics: readonly WorkflowDiagnostic[]) =>
+  diagnostics.some(
+    (diagnostic) =>
+      diagnostic.severity === "error" &&
+      (diagnostic.failureScope === "source-change" ||
+        !diagnostic.failureScope ||
+        diagnostic.failureScope === "unknown"),
+  );
+
+const fieldCount = (fields: readonly string[], fieldName: string) =>
+  fields.filter((field) => field === fieldName).length;
+
+const fieldOrderValid = (fields: readonly string[], fieldName: string) => {
+  const actualIndex = fields.indexOf(fieldName);
+  if (actualIndex < 0 || fields.lastIndexOf(fieldName) !== actualIndex) return false;
+  const fieldsWithoutRequested = fields.filter((_, index) => index !== actualIndex);
+  return insertionIndexForFieldOrder(fieldsWithoutRequested, fieldName) === actualIndex;
+};
+
+const workflowModuleContext = async (workspace: Workspace, plan: WorkflowPlan): Promise<AkanModuleContext | null> => {
+  const app = workflowStringInput(plan.inputs.app);
+  const moduleName = workflowStringInput(plan.inputs.module);
+  if (!app || !moduleName) return null;
+  const [apps, libs] = await workspace.getSyss();
+  const sysType = apps.includes(app) ? "app" : libs.includes(app) ? "lib" : null;
+  if (!sysType) return null;
+  const modulePath = `${sysType}s/${app}/lib/${moduleName}`;
+  const files = await workspace.readdir(modulePath);
+  const abstractPath = `${modulePath}/${moduleName}.abstract.md`;
+  return {
+    kind: "domain",
+    name: moduleName,
+    folderName: moduleName,
+    sysName: app,
+    sysType,
+    path: modulePath,
+    abstract: {
+      path: abstractPath,
+      exists: files.includes(`${moduleName}.abstract.md`),
+      headings: [],
+    },
+    files,
+  };
+};
+
+const structureCheck = (
+  code: string,
+  target: string,
+  status: WorkflowPostApplyCheck["status"],
+  message: string,
+): WorkflowPostApplyCheck => ({
+  code,
+  target,
+  status,
+  message,
+});
+
+const checkAddFieldStructure = async (workspace: Workspace, plan: WorkflowPlan): Promise<WorkflowStepResult> => {
+  if (plan.workflow !== "add-field" && plan.workflow !== "add-enum-field") return {};
+  const app = workflowStringInput(plan.inputs.app);
+  const moduleName = workflowStringInput(plan.inputs.module);
+  const fieldName = workflowStringInput(plan.inputs.field);
+  const typeName = workflowStringInput(plan.inputs.type);
+  if (!app || !moduleName || !fieldName || !typeName) return {};
+
+  const moduleContext = await workflowModuleContext(workspace, plan);
+  if (!moduleContext) return {};
+
+  const paths = moduleSourcePaths(moduleName);
+  const constantPath = `${moduleContext.path}/${paths.constant.replace(`lib/${moduleName}/`, "")}`;
+  const dictionaryPath = `${moduleContext.path}/${paths.dictionary.replace(`lib/${moduleName}/`, "")}`;
+  const moduleClassName = moduleComponentName(moduleName);
+  const inputClassName = `${moduleClassName}Input`;
+  const index = await buildAkanModuleContextIndex(workspace, moduleContext, { field: fieldName });
+  const diagnostics: WorkflowDiagnostic[] = [];
+  const postApplyChecks: WorkflowPostApplyCheck[] = [];
+
+  const constantContent = await workspace.readFile(constantPath);
+  const constantStructure = inspectConstantStructure(constantContent, inputClassName, moduleClassName);
+  const constantNames = constantStructure.fields.map((field) => field.name);
+  const requestedConstantFields = constantStructure.fields.filter((field) => field.name === fieldName);
+  const normalizedType = typeName.toLowerCase() === "enum" ? typeName : normalizeFieldType(typeName);
+  const constantFailures = [
+    !constantStructure.parseValid ? "constant file does not parse" : null,
+    !constantStructure.inputObjectFound ? `${inputClassName} via builder object was not found` : null,
+    requestedConstantFields.length !== 1
+      ? `field "${fieldName}" appears ${requestedConstantFields.length} time(s) in ${inputClassName}`
+      : null,
+    constantStructure.builderName &&
+    requestedConstantFields[0]?.expressionBuilder &&
+    requestedConstantFields[0].expressionBuilder !== constantStructure.builderName
+      ? `field "${fieldName}" uses builder "${requestedConstantFields[0].expressionBuilder}" instead of "${constantStructure.builderName}"`
+      : null,
+    !constantStructure.builderName ? `${inputClassName} via builder parameter was not found` : null,
+    (normalizedType === "Int" || normalizedType === "Float") && !constantStructure.baseImports.includes(normalizedType)
+      ? `missing ${normalizedType} import from "akanjs/base"`
+      : null,
+    workflowBooleanInput(plan.inputs.includeInLight) === true &&
+    fieldCount(constantStructure.lightProjectionFields, fieldName) !== 1
+      ? `field "${fieldName}" is not present exactly once in Light${moduleClassName}`
+      : null,
+    ...index.diagnostics
+      .filter((diagnostic) => diagnostic.severity === "error" && diagnostic.context?.paths?.includes(constantPath))
+      .map((diagnostic) => diagnostic.message),
+  ].filter((failure): failure is string => failure !== null);
+  const constantValid = constantFailures.length === 0;
+  postApplyChecks.push(
+    structureCheck(
+      constantValid ? "workflow-post-apply-constant-shape-valid" : "workflow-post-apply-structure-invalid",
+      constantPath,
+      constantValid ? "passed" : "failed",
+      constantValid
+        ? `${inputClassName} keeps via structure, builder usage, imports, and requested field presence.`
+        : constantFailures.join(" "),
+    ),
+  );
+  if (!constantValid) {
+    diagnostics.push(
+      postApplyDiagnostic("workflow-post-apply-structure-invalid", constantFailures.join(" "), constantPath),
+    );
+  }
+
+  const dictionaryContent = await workspace.readFile(dictionaryPath);
+  const dictionaryStructure = inspectDictionaryStructure(dictionaryContent, moduleClassName);
+  const dictionaryFailures = [
+    !dictionaryStructure.parseValid ? "dictionary file does not parse" : null,
+    !dictionaryStructure.modelObjectFound ? `.model<${moduleClassName}> object was not found` : null,
+    dictionaryStructure.modelObjectFound && !dictionaryStructure.chainOrderValid
+      ? `.model(), .slice(), .enum(), .error(), and .translate() chain order is broken: ${dictionaryStructure.chainMethods.join(
+          " -> ",
+        )}`
+      : null,
+    fieldCount(dictionaryStructure.fields, fieldName) !== 1
+      ? `field "${fieldName}" appears ${fieldCount(dictionaryStructure.fields, fieldName)} time(s) in .model<${moduleClassName}>`
+      : null,
+    ...index.diagnostics
+      .filter((diagnostic) => diagnostic.severity === "error" && diagnostic.context?.paths?.includes(dictionaryPath))
+      .map((diagnostic) => diagnostic.message),
+  ].filter((failure): failure is string => failure !== null);
+  const dictionaryValid = dictionaryFailures.length === 0;
+  postApplyChecks.push(
+    structureCheck(
+      dictionaryValid ? "workflow-post-apply-dictionary-shape-valid" : "workflow-post-apply-structure-invalid",
+      dictionaryPath,
+      dictionaryValid ? "passed" : "failed",
+      dictionaryValid
+        ? `.model<${moduleClassName}> keeps the requested field inside the model object and preserves dictionary chain order.`
+        : dictionaryFailures.join(" "),
+    ),
+  );
+  if (!dictionaryValid) {
+    diagnostics.push(
+      postApplyDiagnostic("workflow-post-apply-structure-invalid", dictionaryFailures.join(" "), dictionaryPath),
+    );
+  }
+
+  const constantOrderValid = fieldOrderValid(constantNames, fieldName);
+  const dictionaryOrderValid = fieldOrderValid(dictionaryStructure.fields, fieldName);
+  const orderValid = constantOrderValid && dictionaryOrderValid;
+  postApplyChecks.push(
+    structureCheck(
+      "workflow-post-apply-field-order-valid",
+      `${constantPath}, ${dictionaryPath}`,
+      orderValid ? "passed" : "failed",
+      orderValid
+        ? `Field "${fieldName}" follows the shared priority ordering policy.`
+        : `Field "${fieldName}" is present but does not match the shared priority ordering policy.`,
+    ),
+  );
+  if (!orderValid) {
+    diagnostics.push(
+      postApplyWarning(
+        "workflow-post-apply-field-order-mismatch",
+        `Field "${fieldName}" is present but does not match the shared priority ordering policy.`,
+        `${constantPath}, ${dictionaryPath}`,
+      ),
+    );
+  }
+
+  return { diagnostics, postApplyChecks };
+};
+
+const resolveWorkflowSys = async (workspace: Workspace, target: string | null): Promise<Sys | null> => {
+  if (!target) return null;
+  const [apps, libs] = await workspace.getSyss();
+  if (apps.includes(target)) return AppExecutor.from(workspace, target);
+  if (libs.includes(target)) return LibExecutor.from(workspace, target);
+  return null;
+};
+
+const targetMissing = (input = "app"): WorkflowDiagnostic => ({
+  severity: "error",
+  code: "workflow-target-missing",
+  input,
+  message: "Workflow target app or library was not found.",
+});
+
+const inputMissing = (input: string): WorkflowDiagnostic => ({
+  severity: "error",
+  code: "workflow-input-missing",
+  input,
+  message: `Workflow input "${input}" is required for apply.`,
+});
+
+const unsupportedInput = (input: string, message: string): WorkflowDiagnostic => ({
+  severity: "error",
+  code: "workflow-input-unsupported",
+  input,
+  message,
+});
+
+const addFieldUiSurfaceInspection = (plan: WorkflowPlan): WorkflowStepResult => {
+  const app = workflowStringInput(plan.inputs.app);
+  const module = workflowStringInput(plan.inputs.module) ?? "<module>";
+  const field = workflowStringInput(plan.inputs.field) ?? "<field>";
+  const typeName = workflowStringInput(plan.inputs.type);
+  const policy = addFieldUiPolicyForType(typeName ?? "String");
+  const surfaces = workflowStringArrayInput(plan.inputs.surfaces);
+  const templateRequested = surfaces?.includes("template") ?? false;
+  const moduleClassName = moduleComponentName(module);
+  const target = `${app ? `apps/${app}` : "*"}/${moduleSourcePaths(module).template}`;
+  return {
+    recommendations: [
+      {
+        code: "add-field-ui-surface-review",
+        kind: "manual-action",
+        target,
+        action: templateRequested
+          ? `Template was requested for ${field}. If no Template file changed, users will not see the field in the form yet because the file was missing, the generated ${module}Form/Layout.Template pattern was not found, or ${policy.component} needs option binding. Add it inside Layout.Template near existing Field components.`
+          : `Template was not selected, so users will not see ${field} in the form from this apply. If list/card display is needed, include ${field} in Light${moduleClassName} projection data and place it in the local Unit/View card layout.`,
+        confidence: "medium",
+        message: `Review user-visible UI for ${module}.${field}; recommended component is ${policy.component}.`,
+      },
+    ],
+    nextActions: [
+      {
+        command: `akan workflow explain ${plan.workflow}`,
+        reason: "Review UI surface guidance before manually editing ambiguous UI files.",
+      },
+    ],
+  };
+};
+
+export const createWorkflowStepRegistry = ({
+  workspace,
+  createModule,
+  createScalar,
+  createUi,
+  addField,
+  addEnumField,
+}: WorkflowPrimitiveOperations): WorkflowStepRegistry => {
+  const inspect = async () => undefined;
+  const commandOnly = async () => undefined;
+
+  return {
+    inspectSystem: inspect,
+    inspectModule: inspect,
+    syncTarget: commandOnly,
+    lintTarget: commandOnly,
+    [workflowStepKey("create-module", "create-module")]: async (_step, plan) => {
+      const app = workflowStringInput(plan.inputs.app);
+      const module = workflowStringInput(plan.inputs.module);
+      const sys = await resolveWorkflowSys(workspace, app);
+      if (!sys || !module) return { diagnostics: [!sys ? targetMissing() : inputMissing("module")] };
+      return primitiveReportToWorkflowStepResult(await createModule(sys, module));
+    },
+    [workflowStepKey("create-scalar", "create-scalar")]: async (_step, plan) => {
+      const app = workflowStringInput(plan.inputs.app);
+      const scalar = workflowStringInput(plan.inputs.scalar);
+      const sys = await resolveWorkflowSys(workspace, app);
+      if (!sys || !scalar) return { diagnostics: [!sys ? targetMissing() : inputMissing("scalar")] };
+      return primitiveReportToWorkflowStepResult(await createScalar(sys, scalar));
+    },
+    [workflowStepKey("create-ui", "create-ui")]: async (_step, plan) => {
+      const surface = workflowStringInput(plan.inputs.surface);
+      if (surface !== "view" && surface !== "unit" && surface !== "template") {
+        return {
+          diagnostics: [
+            unsupportedInput("surface", "Workflow apply currently supports create-ui surfaces: view, unit, template."),
+          ],
+        };
+      }
+      return primitiveReportToWorkflowStepResult(
+        await createUi({
+          app: workflowStringInput(plan.inputs.app),
+          module: workflowStringInput(plan.inputs.module),
+          surface,
+        }),
+      );
+    },
+    [workflowStepKey("add-field", "update-constant")]: async (_step, plan) => {
+      if (workflowStringInput(plan.inputs.type)?.toLowerCase() === "enum") {
+        return primitiveReportToWorkflowStepResult(
+          await addEnumField({
+            app: workflowStringInput(plan.inputs.app),
+            module: workflowStringInput(plan.inputs.module),
+            field: workflowStringInput(plan.inputs.field),
+            values: workflowStringListInput(plan.inputs.values),
+            defaultValue: workflowStringInput(plan.inputs.default),
+            surfaces: workflowStringArrayInput(plan.inputs.surfaces),
+            includeInLight: workflowBooleanInput(plan.inputs.includeInLight),
+          }),
+        );
+      }
+      return primitiveReportToWorkflowStepResult(
+        await addField({
+          app: workflowStringInput(plan.inputs.app),
+          module: workflowStringInput(plan.inputs.module),
+          field: workflowStringInput(plan.inputs.field),
+          type: workflowStringInput(plan.inputs.type),
+          defaultValue: workflowStringInput(plan.inputs.default),
+          surfaces: workflowStringArrayInput(plan.inputs.surfaces),
+          includeInLight: workflowBooleanInput(plan.inputs.includeInLight),
+        }),
+      );
+    },
+    [workflowStepKey("add-field", "update-dictionary")]: inspect,
+    [workflowStepKey("add-field", "update-ui-surfaces")]: async (_step, plan) => addFieldUiSurfaceInspection(plan),
+    [workflowStepKey("add-enum-field", "update-constant")]: async (_step, plan) =>
+      primitiveReportToWorkflowStepResult(
+        await addEnumField({
+          app: workflowStringInput(plan.inputs.app),
+          module: workflowStringInput(plan.inputs.module),
+          field: workflowStringInput(plan.inputs.field),
+          values: workflowStringListInput(plan.inputs.values),
+          defaultValue: workflowStringInput(plan.inputs.default),
+        }),
+      ),
+    [workflowStepKey("add-enum-field", "update-dictionary")]: inspect,
+    [workflowStepKey("add-enum-field", "update-option")]: inspect,
+  };
+};
+
+export const createWorkflowStepCommandResult = (
+  step: WorkflowStep,
+  command: string,
+  reason: string,
+): WorkflowStepResult => ({
+  commands: [{ command, reason, stepId: step.id }],
+  nextActions: [{ command, reason }],
+});
+
+export class WorkflowExecutor {
+  constructor(
+    private readonly registry: WorkflowStepRegistry,
+    private readonly workspace?: Workspace,
+  ) {}
+
+  async apply(plan: WorkflowPlan) {
+    const changedFiles: PrimitiveChangedFile[] = [];
+    const generatedFiles: PrimitiveGeneratedFile[] = [];
+    const recommendedValidationCommands: WorkflowApplyCommand[] = [];
+    const diagnostics: WorkflowDiagnostic[] = [...plan.diagnostics];
+    const postApplyChecks: WorkflowPostApplyCheck[] = [];
+    const recommendations = [...plan.recommendations];
+    const nextActions: PrimitiveNextAction[] = [];
+
+    if (diagnostics.some((diagnostic) => diagnostic.severity === "error")) {
+      return createWorkflowApplyReport({
+        workflow: plan.workflow,
+        mode: "apply",
+        changedFiles,
+        generatedFiles,
+        recommendedValidationCommands,
+        diagnostics,
+        postApplyChecks,
+        recommendations,
+        nextActions,
+        plan,
+      });
+    }
+
+    recommendedValidationCommands.push(...workflowCommandsForPlan(plan));
+    nextActions.push(...workflowCommandsForPlan(plan));
+
+    for (const step of plan.steps) {
+      const runner =
+        this.registry[workflowStepKey(plan.workflow, step.id)] ?? this.registry[step.tool] ?? this.registry[step.id];
+      if (!runner) {
+        diagnostics.push({
+          severity: "error",
+          code: "workflow-step-unsupported",
+          message: `Workflow ${plan.workflow} step "${step.id}" is not supported by workflow apply yet.`,
+        });
+        nextActions.push({
+          command: `akan workflow explain ${plan.workflow}`,
+          reason: "Review the unsupported workflow step before retrying apply.",
+        });
+        break;
+      }
+
+      const result = await runner(step, plan);
+      if (!result) continue;
+      changedFiles.push(...(result.changedFiles ?? []));
+      generatedFiles.push(...(result.generatedFiles ?? []));
+      recommendedValidationCommands.push(...(result.commands ?? []));
+      diagnostics.push(...(result.diagnostics ?? []));
+      recommendations.push(...(result.recommendations ?? []));
+      nextActions.push(...(result.nextActions ?? []));
+      if (diagnostics.some((diagnostic) => diagnostic.severity === "error")) break;
+    }
+
+    if (this.workspace && !diagnostics.some((diagnostic) => diagnostic.severity === "error")) {
+      for (const file of changedFiles) {
+        const result = await checkChangedFile(this.workspace, file);
+        postApplyChecks.push(...(result.postApplyChecks ?? []));
+        diagnostics.push(...(result.diagnostics ?? []));
+      }
+      if (!sourceChangeError(diagnostics)) {
+        const result = await checkAddFieldStructure(this.workspace, plan);
+        postApplyChecks.push(...(result.postApplyChecks ?? []));
+        diagnostics.push(...(result.diagnostics ?? []));
+      }
+      const recommendationDiagnostics = await Promise.all(
+        recommendations.map((recommendation) => checkRecommendationPath(this.workspace as Workspace, recommendation)),
+      );
+      diagnostics.push(
+        ...recommendationDiagnostics.filter((diagnostic): diagnostic is WorkflowDiagnostic => !!diagnostic),
+      );
+    }
+
+    return createWorkflowApplyReport({
+      workflow: plan.workflow,
+      mode: "apply",
+      changedFiles,
+      generatedFiles,
+      recommendedValidationCommands,
+      diagnostics,
+      postApplyChecks,
+      recommendations,
+      nextActions,
+      plan,
+    });
+  }
+}

package/workflow/index.ts

@@ -0,0 +1,11 @@
+export * from "./artifacts";
+export * from "./executor";
+export * from "./moduleIndex";
+export * from "./plan";
+export * from "./primitive";
+export * from "./render";
+export * from "./rolloutGate";
+export * from "./source";
+export * from "./types";
+export * from "./uiPolicy";
+export * from "./utils";