stageflow 0.13.0 → 0.16.0

package/dist/config/mergePipelineIncludes.js

@@ -1,7 +1,10 @@
 import path from "node:path";
 import { parseAgentField } from "../agent/agentBackend.js";
 import { loadFailure, loadSuccess } from "./loadOutcome.js";
+import { allowLegacyYamlAuthoring, dialectWarningForDocument, legacyAuthoringRejected, presentLegacyKeys, } from "./legacyYaml.js";
+import { parseModelField } from "./modelField.js";
 import { readYamlObject } from "./readYamlObject.js";
+import { classifyYamlDocument, collectDocumentKeys, mixedDialectIssue, } from "./yamlDialect.js";
 function isPlainObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -12,7 +15,7 @@ function formatIncludeCycle(stack, nextPath) {
     const chain = [...stack, nextPath].map((p) => path.basename(p));
     return chain.join(" → ");
 }
-async function visitPipelineFile(filePath, stack, idLocations, entries) {
+async function visitPipelineFile(filePath, stack, idLocations, entries, warnings) {
     const absPath = normalizePath(filePath);
     if (stack.some((p) => normalizePath(p) === absPath)) {
         const cycleChain = formatIncludeCycle(stack, absPath);
@@ -38,6 +41,28 @@ async function visitPipelineFile(filePath, stack, idLocations, entries) {
             },
         ]);
     }
+    const dialect = classifyYamlDocument(raw);
+    if (dialect === "invalid") {
+        return loadFailure([mixedDialectIssue()]);
+    }
+    const rejected = legacyAuthoringRejected(dialect, absPath, presentLegacyKeys(collectDocumentKeys(raw)));
+    if (rejected)
+        return loadFailure([rejected]);
+    if (allowLegacyYamlAuthoring()) {
+        const warning = dialectWarningForDocument(raw, absPath);
+        if (warning)
+            warnings.push(warning);
+    }
+    const isFragment = stack.length > 0;
+    if (isFragment && raw.schemas !== undefined) {
+        return loadFailure([
+            {
+                code: "pipeline.include_invalid",
+                message: `Invalid include in ${absPath}: schemas is only allowed on the pipeline file, not on include fragments`,
+                category: "pipeline",
+            },
+        ]);
+    }
     const nextStack = [...stack, absPath];
     if (raw.include !== undefined) {
         if (!Array.isArray(raw.include)) {
@@ -61,7 +86,7 @@ async function visitPipelineFile(filePath, stack, idLocations, entries) {
                 ]);
             }
             const includePath = normalizePath(path.resolve(path.dirname(absPath), item.local));
-            const includeResult = await visitPipelineFile(includePath, nextStack, idLocations, entries);
+            const includeResult = await visitPipelineFile(includePath, nextStack, idLocations, entries, warnings);
             if (!includeResult.ok)
                 return includeResult;
         }
@@ -136,9 +161,26 @@ export async function mergePipelineStages(rootPath) {
         ]);
     }
     const agent = agentField.value;
+    const modelField = parseModelField(raw.model);
+    if (!modelField.ok) {
+        return loadFailure([
+            {
+                code: "pipeline.invalid_model",
+                message: `Invalid pipeline ${absRoot}: ${modelField.message}`,
+                category: "pipeline",
+                pipelineId,
+            },
+        ]);
+    }
+    const model = modelField.value;
+    const schemasOutcome = parsePipelineSchemas(raw.schemas, absRoot, pipelineId);
+    if (!schemasOutcome.ok)
+        return schemasOutcome;
+    const schemas = schemasOutcome.value;
     const idLocations = new Map();
     const entries = [];
-    const mergeResult = await visitPipelineFile(absRoot, [], idLocations, entries);
+    const warnings = [];
+    const mergeResult = await visitPipelineFile(absRoot, [], idLocations, entries, warnings);
     if (!mergeResult.ok)
         return mergeResult;
     if (entries.length === 0) {
@@ -150,5 +192,41 @@ export async function mergePipelineStages(rootPath) {
             },
         ]);
     }
-    return loadSuccess({ entries, pipelineId, ...(agent !== undefined ? { agent } : {}) });
+    return loadSuccess({
+        entries,
+        pipelineId,
+        ...(agent !== undefined ? { agent } : {}),
+        ...(model !== undefined ? { model } : {}),
+        ...(schemas !== undefined ? { schemas } : {}),
+        warnings,
+    });
+}
+function parsePipelineSchemas(raw, absPath, pipelineId) {
+    if (raw === undefined)
+        return loadSuccess(undefined);
+    if (!isPlainObject(raw)) {
+        return loadFailure([
+            {
+                code: "pipeline.invalid_shape",
+                message: `Invalid pipeline ${absPath}: schemas must be an object`,
+                category: "pipeline",
+                pipelineId,
+            },
+        ]);
+    }
+    const schemas = {};
+    for (const [name, value] of Object.entries(raw)) {
+        if (value === null || typeof value !== "object" || Array.isArray(value)) {
+            return loadFailure([
+                {
+                    code: "pipeline.invalid_shape",
+                    message: `Invalid pipeline ${absPath}: schemas.${name} must be an object`,
+                    category: "pipeline",
+                    pipelineId,
+                },
+            ]);
+        }
+        schemas[name] = value;
+    }
+    return loadSuccess(schemas);
 }

package/dist/config/migrateYaml.d.ts

@@ -0,0 +1,19 @@
+export type MigrateYamlWrite = {
+    file: string;
+    absPath: string;
+    content: string;
+};
+export type MigrateYamlPlan = {
+    writes: MigrateYamlWrite[];
+    skipped: string[];
+    errors: string[];
+};
+export declare function catalogKind(raw: Record<string, unknown>, filePath: string): "pipeline" | "stage" | "task" | "unknown";
+export declare function fileDirtyVsHead(absPath: string): boolean;
+export declare function planMigrateYaml(targetPath: string, options?: {
+    cwd: string;
+    projectRoot?: string;
+}): Promise<MigrateYamlPlan>;
+export declare function applyMigrateYamlPlan(plan: MigrateYamlPlan, testOnly?: {
+    beforeRename?: () => Promise<void>;
+}): Promise<void>;