stageflow 0.1.0 → 0.3.0

package/dist/config/createStage.js

@@ -43,6 +43,16 @@ export function parseCreateStageBody(body) {
     if ("skill" in body) {
         return { ok: false, status: 400, error: "skill is not supported" };
     }
+    if (typeof body.pipeline_directory !== "string" || !body.pipeline_directory.trim()) {
+        return { ok: false, status: 400, error: "pipeline_directory is required" };
+    }
+    if (typeof body.filename !== "string" || !body.filename.trim()) {
+        return { ok: false, status: 400, error: "filename is required" };
+    }
+    const filename = body.filename.trim().replace(/\\/g, "/");
+    if (!filename.endsWith(".yaml") && !filename.endsWith(".yml")) {
+        return { ok: false, status: 400, error: "filename must end with .yaml" };
+    }
     if (typeof body.id !== "string") {
         return { ok: false, status: 400, error: "id is required" };
     }
@@ -65,6 +75,8 @@ export function parseCreateStageBody(body) {
         };
     }
     return {
+        pipeline_directory: body.pipeline_directory.trim().replace(/\\/g, "/"),
+        filename,
         id: body.id,
         system_prompt: body.system_prompt,
         model: body.model,
@@ -112,14 +124,21 @@ async function fileExists(filePath) {
         return false;
     }
 }
-async function findStageIdCollision(cwd, id, targetPath) {
+function resolvePipelineDirectory(projectRoot, pipelineDirectory) {
+    const absDirectory = path.resolve(projectRoot, pipelineDirectory);
+    const rel = path.relative(projectRoot, absDirectory);
+    if (rel.startsWith("..") || path.isAbsolute(rel)) {
+        return null;
+    }
+    return absDirectory;
+}
+async function findStageIdCollision(pipelineDirectory, projectRoot, id, targetPath) {
     if (await fileExists(targetPath)) {
-        return path.relative(cwd, targetPath);
+        return path.relative(projectRoot, targetPath);
     }
-    const dir = path.join(cwd, "stages");
     let entries;
     try {
-        entries = await readdir(dir, { withFileTypes: true });
+        entries = await readdir(pipelineDirectory, { withFileTypes: true });
     }
     catch {
         return null;
@@ -127,13 +146,13 @@ async function findStageIdCollision(cwd, id, targetPath) {
     for (const entry of entries) {
         if (!entry.isFile() || !entry.name.endsWith(".yaml"))
             continue;
-        const filePath = path.join(dir, entry.name);
+        const filePath = path.join(pipelineDirectory, entry.name);
         if (filePath === targetPath)
             continue;
         try {
             const raw = await readYamlObject(filePath);
             if (raw?.id === id) {
-                return path.relative(cwd, filePath);
+                return path.relative(projectRoot, filePath);
             }
         }
         catch {
@@ -142,11 +161,18 @@ async function findStageIdCollision(cwd, id, targetPath) {
     }
     return null;
 }
-export async function createStage(cwd, input) {
-    const stagesDir = path.join(cwd, "stages");
-    const filePath = path.join(stagesDir, `${input.id}.yaml`);
-    const relPath = path.relative(cwd, filePath);
-    const collision = await findStageIdCollision(cwd, input.id, filePath);
+export async function createStage(projectRoot, input) {
+    const pipelineDirectory = resolvePipelineDirectory(projectRoot, input.pipeline_directory);
+    if (!pipelineDirectory) {
+        return {
+            ok: false,
+            status: 400,
+            error: "pipeline_directory must be inside the project root",
+        };
+    }
+    const filePath = path.join(pipelineDirectory, path.basename(input.filename));
+    const relPath = path.relative(projectRoot, filePath).replace(/\\/g, "/");
+    const collision = await findStageIdCollision(pipelineDirectory, projectRoot, input.id, filePath);
     if (collision) {
         return {
             ok: false,
@@ -155,8 +181,13 @@ export async function createStage(cwd, input) {
         };
     }
     try {
-        await mkdir(stagesDir, { recursive: true });
-        await writeFile(filePath, stageConfigToYaml(input), "utf8");
+        await mkdir(pipelineDirectory, { recursive: true });
+        await writeFile(filePath, stageConfigToYaml({
+            id: input.id,
+            system_prompt: input.system_prompt,
+            model: input.model,
+            ...(input.gate_kinds ? { gate_kinds: input.gate_kinds } : {}),
+        }), "utf8");
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
@@ -169,7 +200,6 @@ export async function createStage(cwd, input) {
             stage: {
                 path: relPath,
                 id: stage.id,
-                used_by_pipeline_ids: [],
                 ...(stage.gate_kinds ? { gate_kinds: stage.gate_kinds } : {}),
             },
         };

package/dist/config/listConfig.d.ts

@@ -1,18 +1,9 @@
-import { type StageGateKind } from "../types/stage.js";
-export type TaskListing = {
-    path: string;
-    id: string;
-    goal: string;
-};
-export type PipelineStageListing = {
-    id: string;
-    gate_kinds?: StageGateKind[];
-};
-export type PipelineListing = {
-    path: string;
-    id: string;
-    stages: PipelineStageListing[];
-};
+import type { StageGateKind } from "../types/stage.js";
+import type { LoadedManifest } from "../types/stageflowManifest.js";
+import { type PipelineListing, type TaskListing } from "./browseCatalog.js";
+import { type StageflowContext } from "../project/resolveStageflowContext.js";
+import { type CatalogContext } from "./resolveCatalogContext.js";
+export type { PipelineListing, PipelineStageListing, TaskListing } from "./browseCatalog.js";
 export type ValidStageListing = {
     path: string;
     id: string;
@@ -27,7 +18,11 @@ export type BrokenStageListing = {
     gate_kinds?: StageGateKind[];
 };
 export type StageListing = ValidStageListing | BrokenStageListing;
-export declare function listTasks(cwd: string): Promise<TaskListing[]>;
-export declare function listPipelines(cwd: string): Promise<PipelineListing[]>;
-export declare function listStages(cwd: string): Promise<StageListing[]>;
-export declare function listModels(cwd: string): Promise<string[]>;
+export type CatalogListOptions = {
+    projectRoot: string;
+    manifest: LoadedManifest;
+};
+export declare function listTasks(options: CatalogListOptions): Promise<TaskListing[]>;
+export declare function listPipelines(options: CatalogListOptions): Promise<PipelineListing[]>;
+export declare function listStages(_options?: unknown): Promise<StageListing[]>;
+export declare function listModels(cwdOrContext: string | CatalogContext | StageflowContext): Promise<string[]>;

package/dist/config/listConfig.js

@@ -1,195 +1,30 @@
-import { readdir } from "node:fs/promises";
-import path from "node:path";
-import { STAGE_GATE_KINDS, } from "../types/stage.js";
-import { loadPipeline } from "./loadPipeline.js";
-import { loadStage } from "./loadStage.js";
-import { loadTask } from "./loadTask.js";
-import { readYamlObject } from "./readYamlObject.js";
-import { extractPipelineStageIds } from "./resolvePipelineDag.js";
-const BAKED_MODEL_IDS = [
-    "anthropic/claude-sonnet-4-5",
-    "cursor/auto",
-    "cursor/composer-2-5",
-];
-function parseSafeGateKinds(raw) {
-    if (!Array.isArray(raw) || !raw.every((item) => typeof item === "string")) {
-        return undefined;
-    }
-    const allowed = new Set(STAGE_GATE_KINDS);
-    const gateKinds = raw.filter((item) => allowed.has(item));
-    return gateKinds.length > 0 ? gateKinds : undefined;
+import { listModelsForContext, listPipelinesForContext, listTasksForContext, } from "./browseCatalog.js";
+import { resolveStageflowContext } from "../project/resolveStageflowContext.js";
+import { catalogContextFromStageflow } from "./resolveCatalogContext.js";
+export async function listTasks(options) {
+    return listTasksForContext({
+        projectRoot: options.projectRoot,
+        manifest: options.manifest,
+        manifestStatus: "ok",
+        issues: [],
+    });
 }
-async function listPipelineUsageByStage(cwd) {
-    const dir = path.join(cwd, "pipelines");
-    let entries;
-    try {
-        entries = await readdir(dir, { withFileTypes: true });
-    }
-    catch {
-        return new Map();
-    }
-    const usage = new Map();
-    for (const entry of entries) {
-        if (!entry.isFile() || !entry.name.endsWith(".yaml"))
-            continue;
-        const filePath = path.join(dir, entry.name);
-        try {
-            const raw = await readYamlObject(filePath);
-            if (typeof raw?.id !== "string" || !Array.isArray(raw.stages))
-                continue;
-            const stageIds = extractPipelineStageIds(raw.stages);
-            if (!stageIds)
-                continue;
-            for (const stageId of stageIds) {
-                let pipelineIds = usage.get(stageId);
-                if (!pipelineIds) {
-                    pipelineIds = new Set();
-                    usage.set(stageId, pipelineIds);
-                }
-                pipelineIds.add(raw.id);
-            }
-        }
-        catch {
-            // skip invalid pipeline files
-        }
-    }
-    return usage;
+export async function listPipelines(options) {
+    return listPipelinesForContext({
+        projectRoot: options.projectRoot,
+        manifest: options.manifest,
+        manifestStatus: "ok",
+        issues: [],
+    });
 }
-export async function listTasks(cwd) {
-    const dir = path.join(cwd, "tasks");
-    let entries;
-    try {
-        entries = await readdir(dir, { withFileTypes: true });
-    }
-    catch {
-        return [];
-    }
-    const listings = [];
-    for (const entry of entries) {
-        if (!entry.isFile() || !entry.name.endsWith(".yaml"))
-            continue;
-        const filePath = path.join(dir, entry.name);
-        try {
-            const task = await loadTask(filePath);
-            listings.push({
-                path: path.relative(cwd, filePath),
-                id: task.id,
-                goal: task.goal,
-            });
-        }
-        catch {
-            // skip invalid
-        }
-    }
-    listings.sort((a, b) => a.id.localeCompare(b.id));
-    return listings;
+export async function listStages(_options) {
+    return [];
 }
-export async function listPipelines(cwd) {
-    const dir = path.join(cwd, "pipelines");
-    let entries;
-    try {
-        entries = await readdir(dir, { withFileTypes: true });
-    }
-    catch {
-        return [];
-    }
-    const listings = [];
-    for (const entry of entries) {
-        if (!entry.isFile() || !entry.name.endsWith(".yaml"))
-            continue;
-        const filePath = path.join(dir, entry.name);
-        try {
-            const loaded = await loadPipeline(filePath, { cwd });
-            listings.push({
-                path: path.relative(cwd, filePath),
-                id: loaded.pipeline.id,
-                stages: loaded.stages.map((stage) => ({
-                    id: stage.id,
-                    ...(stage.gate_kinds ? { gate_kinds: stage.gate_kinds } : {}),
-                })),
-            });
-        }
-        catch {
-            // skip invalid
-        }
-    }
-    listings.sort((a, b) => a.id.localeCompare(b.id));
-    return listings;
-}
-export async function listStages(cwd) {
-    const dir = path.join(cwd, "stages");
-    let entries;
-    try {
-        entries = await readdir(dir, { withFileTypes: true });
-    }
-    catch {
-        return [];
-    }
-    const usageByStage = await listPipelineUsageByStage(cwd);
-    const valid = [];
-    const broken = [];
-    for (const entry of entries) {
-        if (!entry.isFile() || !entry.name.endsWith(".yaml"))
-            continue;
-        const filePath = path.join(dir, entry.name);
-        const relPath = path.relative(cwd, filePath);
-        try {
-            const stage = await loadStage(filePath);
-            valid.push({
-                path: relPath,
-                id: stage.id,
-                used_by_pipeline_ids: [...(usageByStage.get(stage.id) ?? new Set())].sort(),
-                ...(stage.gate_kinds ? { gate_kinds: stage.gate_kinds } : {}),
-            });
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            const brokenRow = {
-                path: relPath,
-                error: message,
-            };
-            try {
-                const raw = await readYamlObject(filePath);
-                if (typeof raw?.id === "string")
-                    brokenRow.id = raw.id;
-                if (typeof raw?.model === "string")
-                    brokenRow.model = raw.model;
-                const gateKinds = parseSafeGateKinds(raw?.gate_kinds);
-                if (gateKinds)
-                    brokenRow.gate_kinds = gateKinds;
-            }
-            catch {
-                // keep path + error only when parsing itself fails
-            }
-            broken.push(brokenRow);
-        }
-    }
-    valid.sort((a, b) => a.id.localeCompare(b.id));
-    broken.sort((a, b) => a.path.localeCompare(b.path));
-    return [...valid, ...broken];
-}
-export async function listModels(cwd) {
-    const dir = path.join(cwd, "stages");
-    const models = new Set(BAKED_MODEL_IDS);
-    let entries;
-    try {
-        entries = await readdir(dir, { withFileTypes: true });
-    }
-    catch {
-        return [...models].sort((a, b) => a.localeCompare(b));
-    }
-    for (const entry of entries) {
-        if (!entry.isFile() || !entry.name.endsWith(".yaml"))
-            continue;
-        try {
-            const raw = await readYamlObject(path.join(dir, entry.name));
-            if (typeof raw?.model === "string" && raw.model.trim()) {
-                models.add(raw.model);
-            }
-        }
-        catch {
-            // ignore unreadable or invalid stage YAML
-        }
-    }
-    return [...models].sort((a, b) => a.localeCompare(b));
+export async function listModels(cwdOrContext) {
+    const ctx = typeof cwdOrContext === "string"
+        ? catalogContextFromStageflow(await resolveStageflowContext(cwdOrContext))
+        : "manifestIssues" in cwdOrContext
+            ? catalogContextFromStageflow(cwdOrContext)
+            : cwdOrContext;
+    return listModelsForContext(ctx);
 }

package/dist/config/listModelsFromManifest.d.ts

@@ -0,0 +1,2 @@
+import type { CatalogContext } from "./resolveCatalogContext.js";
+export declare function listModelsFromManifest(ctx: CatalogContext): Promise<string[]>;

package/dist/config/listModelsFromManifest.js

@@ -0,0 +1,4 @@
+import { listModelsForContext } from "./browseCatalog.js";
+export async function listModelsFromManifest(ctx) {
+    return listModelsForContext(ctx);
+}

package/dist/config/loadOutcome.d.ts

@@ -15,6 +15,10 @@ export type LoadIssue = {
     message: string;
     category: "task";
     taskId?: string;
+} | {
+    code: ValidationFindingCode | string;
+    message: string;
+    category: "catalog";
 };
 export type LoadOutcome<T> = {
     ok: true;

package/dist/config/loadPipeline.d.ts

@@ -1,25 +1,11 @@
 import type { LoadedPipeline } from "../types/pipeline.js";
 import { type LoadOutcome } from "./loadOutcome.js";
-import type { ValidationFinding } from "./validateCatalog.js";
 export type { LoadedPipeline } from "../types/pipeline.js";
 export type { LoadIssue, LoadOutcome } from "./loadOutcome.js";
-export type LoadPipelineValidatedResult = {
-    ok: true;
-    loaded: LoadedPipeline;
-} | {
-    ok: false;
-    findings: ValidationFinding[];
-};
+export declare function resolvePipelinePath(pipelinePath: string, cwd: string): Promise<string>;
 export declare function loadPipelineOutcome(nameOrPath: string, options?: {
     cwd?: string;
-    stagesDir?: string;
 }): Promise<LoadOutcome<LoadedPipeline>>;
-export declare function loadPipelineValidated(nameOrPath: string, options?: {
-    cwd?: string;
-    stagesDir?: string;
-    validateStages?: boolean;
-}): Promise<LoadPipelineValidatedResult>;
 export declare function loadPipeline(nameOrPath: string, options?: {
     cwd?: string;
-    stagesDir?: string;
 }): Promise<LoadedPipeline>;