stageflow 0.1.0 → 0.3.0

package/dist/cli/runOutput.d.ts

@@ -0,0 +1,19 @@
+import type { PipelineRunResult } from "../runtime/pipelineRunner.js";
+import type { StartRunResult } from "../runtime/runManager.js";
+export type CliRunReportIo = {
+    log: (line: string) => void;
+    error: (line: string) => void;
+};
+export type CliRunReportEvent = {
+    kind: "start-failure";
+    started: Extract<StartRunResult, {
+        ok: false;
+    }>;
+} | {
+    kind: "completion";
+    result: PipelineRunResult;
+};
+export declare function reportCliRun(event: CliRunReportEvent, options: {
+    json?: boolean;
+    io: CliRunReportIo;
+}): number;

package/dist/cli/runOutput.js

@@ -0,0 +1,125 @@
+function stringify(payload) {
+    return JSON.stringify(payload, null, 2);
+}
+function isBusyCode(code) {
+    return code === "busy_capacity" || code === "busy_checkout";
+}
+function formatRunBusyJson(started) {
+    const payload = {
+        ok: false,
+        outcome: "busy",
+    };
+    if (started.code !== undefined)
+        payload.code = started.code;
+    payload.reason = started.reason;
+    if (started.activeCount !== undefined)
+        payload.activeCount = started.activeCount;
+    if (started.maxConcurrent !== undefined) {
+        payload.maxConcurrent = started.maxConcurrent;
+    }
+    if (started.activeRunIds !== undefined) {
+        payload.activeRunIds = started.activeRunIds;
+    }
+    if (started.conflictingRunId !== undefined) {
+        payload.conflictingRunId = started.conflictingRunId;
+    }
+    if (started.conflictingCheckout !== undefined) {
+        payload.conflictingCheckout = started.conflictingCheckout;
+    }
+    return stringify(payload);
+}
+function formatRunStartFailedJson(started) {
+    const payload = {
+        ok: false,
+        outcome: "failed",
+        reason: started.reason,
+    };
+    if (started.code !== undefined)
+        payload.code = started.code;
+    return stringify(payload);
+}
+function formatStartFailureJson(started) {
+    if (isBusyCode(started.code)) {
+        return formatRunBusyJson(started);
+    }
+    return formatRunStartFailedJson(started);
+}
+function formatRunCompletionJson(result) {
+    if (result.outcome === "succeeded") {
+        return stringify({
+            ok: true,
+            outcome: "succeeded",
+            runId: result.runId,
+            runDir: result.runDir,
+        });
+    }
+    if (result.outcome === "waiting") {
+        return stringify({
+            ok: false,
+            outcome: "waiting",
+            runId: result.runId,
+            runDir: result.runDir,
+        });
+    }
+    const payload = {
+        ok: false,
+        outcome: "failed",
+        runId: result.runId,
+        runDir: result.runDir,
+    };
+    if (result.reason !== undefined)
+        payload.reason = result.reason;
+    return stringify(payload);
+}
+function writeStartFailureHuman(started, io) {
+    const code = started.code ?? "error";
+    io.error(`${code}: ${started.reason}`);
+    if (started.conflictingRunId !== undefined) {
+        io.error(`conflictingRunId: ${started.conflictingRunId}`);
+    }
+    if (started.conflictingCheckout !== undefined) {
+        io.error(`conflictingCheckout: ${started.conflictingCheckout}`);
+    }
+}
+function writeCompletionHuman(result, io) {
+    switch (result.outcome) {
+        case "waiting":
+            io.error(`Pipeline waiting. Run folder: ${result.runDir} (${result.runId})`);
+            return;
+        case "failed":
+            io.error(`Pipeline failed: ${result.reason}`);
+            io.error(`Run folder: ${result.runDir}`);
+            return;
+        case "succeeded":
+            io.log(`Pipeline succeeded. Run folder: ${result.runDir}`);
+            return;
+    }
+}
+function exitCodeForRunOutcome(outcome) {
+    switch (outcome) {
+        case "succeeded":
+            return 0;
+        case "waiting":
+            return 2;
+        case "failed":
+            return 1;
+    }
+}
+export function reportCliRun(event, options) {
+    if (event.kind === "start-failure") {
+        if (options.json) {
+            options.io.log(formatStartFailureJson(event.started));
+        }
+        else {
+            writeStartFailureHuman(event.started, options.io);
+        }
+        return 1;
+    }
+    if (options.json) {
+        options.io.log(formatRunCompletionJson(event.result));
+    }
+    else {
+        writeCompletionHuman(event.result, options.io);
+    }
+    return exitCodeForRunOutcome(event.result.outcome);
+}

package/dist/cli/validateCommand.d.ts

@@ -1,5 +1,5 @@
 import { validateCatalog as defaultValidateCatalog, type ValidationResult } from "../config/validateCatalog.js";
-export declare const VALIDATE_USAGE = "Usage:\n  sf validate [--pipeline <name-or-path>] [--strict] [--json]";
+export declare const VALIDATE_USAGE = "Usage:\n  sf validate [--pipeline <path>] [--task <path>] [--strict] [--json]\n\n  With no flags, validates all pipelines and tasks declared in stageflow.yaml (manifest-all).\n  --pipeline validates one pipeline file (includes uses:/include: transitively).\n  --task validates one task file.";
 export type ValidateCommandIo = {
     log: (line: string) => void;
     error: (line: string) => void;

package/dist/cli/validateCommand.js

@@ -1,7 +1,11 @@
 import { validateCatalog as defaultValidateCatalog, } from "../config/validateCatalog.js";
 import { exitCodeForValidation, formatValidationHuman, formatValidationJson, } from "./validateOutput.js";
 export const VALIDATE_USAGE = `Usage:
-  sf validate [--pipeline <name-or-path>] [--strict] [--json]`;
+  sf validate [--pipeline <path>] [--task <path>] [--strict] [--json]
+
+  With no flags, validates all pipelines and tasks declared in stageflow.yaml (manifest-all).
+  --pipeline validates one pipeline file (includes uses:/include: transitively).
+  --task validates one task file.`;
 const defaultIo = {
     log: (line) => console.log(line),
     error: (line) => console.error(line),
@@ -14,6 +18,7 @@ function parseValidateArgs(args) {
         return { help: true, strict: false, json: false };
     }
     let pipeline;
+    let task;
     let strict = false;
     let json = false;
     let help = false;
@@ -29,6 +34,13 @@ function parseValidateArgs(args) {
             }
             pipeline = value;
         }
+        else if (arg === "--task") {
+            const value = args[++i];
+            if (value === undefined || value.length === 0) {
+                throw new Error("Missing value for --task");
+            }
+            task = value;
+        }
         else if (arg === "--strict") {
             strict = true;
         }
@@ -42,7 +54,10 @@ function parseValidateArgs(args) {
             throw new Error(`Unexpected argument: ${arg}`);
         }
     }
-    return { help, pipeline, strict, json };
+    if (pipeline !== undefined && task !== undefined) {
+        throw new Error("Use at most one of --pipeline or --task");
+    }
+    return { help, pipeline, task, strict, json };
 }
 export async function runValidateCommand(args, options = {}) {
     const cwd = options.cwd ?? process.cwd();
@@ -54,10 +69,12 @@ export async function runValidateCommand(args, options = {}) {
             out.error(VALIDATE_USAGE);
             return 0;
         }
+        const scope = parsed.pipeline ? "pipeline" : parsed.task ? "task" : "full";
         const result = await validateCatalogFn({
-            scope: parsed.pipeline ? "pipeline" : "full",
+            scope,
             cwd,
             pipeline: parsed.pipeline,
+            task: parsed.task,
             strict: parsed.strict,
         });
         if (parsed.json) {

package/dist/cli.d.ts

@@ -1,2 +1,13 @@
 #!/usr/bin/env node
-export {};
+import type { OperatorCatalog } from "./runtime/stageAttemptBootstrap.js";
+export declare function parseRunStageArgs(argv: string[]): {
+    runId: string;
+    stageId: string;
+    mode?: "run" | "resume";
+    resumeAnswer?: unknown;
+    attempt?: number;
+    sessionFilePath?: string;
+    operatorCatalog?: OperatorCatalog;
+    skipGates?: boolean;
+};
+export declare function sameCliEntry(a: string, b: string): boolean;

package/dist/cli.js

@@ -1,20 +1,23 @@
 #!/usr/bin/env node
 import { spawn } from "node:child_process";
-import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { realpathSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
 import { PiAgentAdapter } from "./agent/piAdapter.js";
+import { INIT_USAGE, runInitCommand } from "./cli/initCommand.js";
 import { PROVIDERS_USAGE, runProvidersCommand } from "./cli/providersCommand.js";
+import { RUN_USAGE, runRunCommand } from "./cli/runCommand.js";
+import { resolveOperatorCatalog } from "./cli/operatorCatalog.js";
 import { VALIDATE_USAGE, runValidateCommand } from "./cli/validateCommand.js";
-import { exitCodeForValidation, formatValidationHuman, } from "./cli/validateOutput.js";
 import { createRunStore } from "./runstore/createStore.js";
-import { PipelineValidationError } from "./runtime/pipelineRunner.js";
-import { RunManager } from "./runtime/runManager.js";
-import { readStageExecutionMode } from "./runtime/stageConcurrency.js";
+import { resolveStageflowContext } from "./project/resolveStageflowContext.js";
 import { exitForOutcome, runStageWorker } from "./runtime/stageWorker.js";
 import { SF_STAGE_WORKER } from "./runtime/stageWorkerProtocol.js";
 import { DEFAULT_PORT, startUiServer } from "./server/http.js";
 const USAGE = `Usage:
-  sf run --task <path> --pipeline <name-or-path> [--checkout <path>]
-  sf validate [--pipeline <name-or-path>] [--strict] [--json]
+  sf init
+  sf run --task <path> --pipeline <path> [--checkout <path>] [--json] [--skip-gates] [--git-sha <sha>] [--ci-pr-url <url>] [--ci-job-url <url>] [--operator-cwd <path>] [--operator-agent-dir <path>]
+  sf validate [--pipeline <path>] [--task <path>] [--strict] [--json]
   sf ui [--port ${DEFAULT_PORT}]
   sf providers list
   sf providers status [--provider <id>]
@@ -28,6 +31,10 @@ Stageflow (sf) runs YAML-defined automatic stage pipelines.
 
 Store backend: SF_STORE=sqlite only. SF_STORE=disk is rejected; disk-era .stageflow/runs trees import when the SQLite store is empty. Data under .stageflow/.
 
+${INIT_USAGE}
+
+${RUN_USAGE}
+
 ${VALIDATE_USAGE}
 
 ${PROVIDERS_USAGE}`;
@@ -41,7 +48,10 @@ function parseArgs(argv) {
         return { help: true };
     }
     const command = args[0];
-    if (command === "providers" || command === "validate") {
+    if (command === "providers" ||
+        command === "validate" ||
+        command === "run" ||
+        command === "init") {
         return { help: false, command };
     }
     if (args.includes("--help") || args.includes("-h")) {
@@ -75,14 +85,16 @@ function parseArgs(argv) {
     }
     return { help: false, command, task, pipeline, port, checkout };
 }
-function parseRunStageArgs(argv) {
+export function parseRunStageArgs(argv) {
     let runId;
     let stageId;
     let mode;
     let resumeAnswer;
     let attempt;
     let sessionFilePath;
+    let operatorCwd;
     let operatorAgentDir;
+    let skipGates = false;
     for (let i = 0; i < argv.length; i++) {
         if (argv[i] === "--run-id") {
             runId = argv[++i];
@@ -126,16 +138,30 @@ function parseRunStageArgs(argv) {
                 throw new Error("Missing value for --session-file");
             }
         }
+        else if (argv[i] === "--operator-cwd") {
+            operatorCwd = argv[++i];
+            if (operatorCwd === undefined) {
+                throw new Error("Missing value for --operator-cwd");
+            }
+        }
         else if (argv[i] === "--operator-agent-dir") {
             operatorAgentDir = argv[++i];
             if (operatorAgentDir === undefined) {
                 throw new Error("Missing value for --operator-agent-dir");
             }
         }
+        else if (argv[i] === "--skip-gates") {
+            skipGates = true;
+        }
     }
     if (!runId || !stageId) {
         throw new Error("Missing --run-id and/or --stage-id");
     }
+    const operatorCatalog = resolveOperatorCatalog({
+        flags: { operatorCwd, operatorAgentDir },
+        env: process.env,
+        defaultCwd: process.cwd(),
+    });
     return {
         runId,
         stageId,
@@ -143,9 +169,8 @@ function parseRunStageArgs(argv) {
         resumeAnswer,
         attempt,
         sessionFilePath,
-        ...(operatorAgentDir !== undefined
-            ? { operatorCatalog: { cwd: process.cwd(), agentDir: operatorAgentDir } }
-            : {}),
+        skipGates,
+        operatorCatalog,
     };
 }
 async function handleInternalRunStage(argv) {
@@ -163,6 +188,7 @@ async function handleInternalRunStage(argv) {
         attempt: parsed.attempt,
         sessionFilePath: parsed.sessionFilePath,
         operatorCatalog: parsed.operatorCatalog,
+        skipGates: parsed.skipGates,
     });
     exitForOutcome(outcome);
 }
@@ -185,18 +211,30 @@ async function main(argv) {
             console.log(USAGE);
             return argv.slice(2).length === 0 ? 1 : 0;
         }
-        const rootDir = process.cwd();
+        const ctx = await resolveStageflowContext(process.cwd());
+        if (parsed.command === "init") {
+            return runInitCommand(argv.slice(3), { cwd: ctx.invocationCwd });
+        }
         if (parsed.command === "validate") {
-            return runValidateCommand(argv.slice(3), { cwd: rootDir });
+            return runValidateCommand(argv.slice(3), { cwd: ctx.invocationCwd });
+        }
+        if (parsed.command === "run") {
+            return runRunCommand(argv.slice(3), {
+                cwd: ctx.invocationCwd,
+                projectRoot: ctx.projectRoot,
+                isGitProject: ctx.isGitProject,
+            });
         }
         if (parsed.command === "providers") {
-            return runProvidersCommand(argv.slice(3), rootDir);
+            return runProvidersCommand(argv.slice(3), ctx.invocationCwd);
         }
-        const store = createRunStore({ rootDir });
+        const store = createRunStore({ rootDir: ctx.projectRoot });
         if (parsed.command === "ui") {
             const { url, mcpUrl } = await startUiServer({
                 agent: new PiAgentAdapter(),
                 store,
+                cwd: ctx.invocationCwd,
+                rootDir: ctx.projectRoot,
                 port: parsed.port,
             });
             console.log(`Operator console: ${url}`);
@@ -214,60 +252,38 @@ async function main(argv) {
             }
             return handleInternalRunStage(subArgs.slice(1));
         }
-        if (parsed.command !== "run") {
-            console.error(`Unknown command: ${parsed.command}`);
-            console.error(USAGE);
-            return 1;
-        }
-        if (!parsed.task || !parsed.pipeline) {
-            console.error("Missing --task and/or --pipeline");
-            console.error(USAGE);
-            return 1;
-        }
-        const manager = new RunManager({
-            agent: new PiAgentAdapter(),
-            store,
-            cwd: rootDir,
-            operatorCatalog: { cwd: rootDir, agentDir: getAgentDir() },
-            executionMode: readStageExecutionMode(process.env, "process"),
-        });
-        const started = await manager.startRun({
-            task: parsed.task,
-            pipeline: parsed.pipeline,
-            checkoutOverride: parsed.checkout,
-        });
-        if (!started.ok) {
-            const code = started.code ?? "error";
-            console.error(`${code}: ${started.reason}`);
-            if (started.conflictingRunId !== undefined) {
-                console.error(`conflictingRunId: ${started.conflictingRunId}`);
-            }
-            if (started.conflictingCheckout !== undefined) {
-                console.error(`conflictingCheckout: ${started.conflictingCheckout}`);
-            }
-            return started.status ?? 1;
-        }
-        const result = await started.done;
-        if (result.ok) {
-            console.log(`Pipeline succeeded. Run folder: ${result.runDir}`);
-            return 0;
-        }
-        console.error(`Pipeline failed: ${result.reason}`);
-        console.error(`Run folder: ${result.runDir}`);
+        console.error(`Unknown command: ${parsed.command}`);
+        console.error(USAGE);
         return 1;
     }
     catch (err) {
-        if (err instanceof PipelineValidationError) {
-            console.error(formatValidationHuman(err.result));
-            return exitCodeForValidation(err.result);
-        }
         console.error(err instanceof Error ? err.message : String(err));
         return 1;
     }
 }
-main(process.argv)
-    .then((code) => process.exit(code))
-    .catch((err) => {
-    console.error(err instanceof Error ? err.message : String(err));
-    process.exit(1);
-});
+function normalizeCliEntry(filePath) {
+    const resolved = path.resolve(filePath);
+    let canonical;
+    try {
+        canonical = realpathSync(resolved);
+    }
+    catch {
+        canonical = resolved;
+    }
+    return canonical.replace(/\.(?:[cm]?[jt]s)$/i, "");
+}
+export function sameCliEntry(a, b) {
+    return normalizeCliEntry(a) === normalizeCliEntry(b);
+}
+function isDirectCliInvocation() {
+    const self = fileURLToPath(import.meta.url);
+    return process.argv.slice(1).some((arg) => sameCliEntry(arg, self));
+}
+if (isDirectCliInvocation()) {
+    main(process.argv)
+        .then((code) => process.exit(code))
+        .catch((err) => {
+        console.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    });
+}

package/dist/config/browseCatalog.d.ts

@@ -0,0 +1,45 @@
+import type { StageGateKind } from "../types/stage.js";
+import type { LoadedManifest } from "../types/stageflowManifest.js";
+import type { LoadIssue } from "./loadOutcome.js";
+import type { CatalogContext } from "./resolveCatalogContext.js";
+import { type CatalogManifestStatus, type StageflowContext } from "../project/resolveStageflowContext.js";
+export type TaskListing = {
+    path: string;
+    id: string;
+    goal: string;
+};
+export type PipelineStageListing = {
+    id: string;
+    gate_kinds?: StageGateKind[];
+    uses_path?: string;
+    inline?: boolean;
+};
+export type PipelineListing = {
+    path: string;
+    id: string;
+    stages: PipelineStageListing[];
+};
+export type CatalogBrowseWarning = {
+    path: string;
+    kind: "pipeline" | "task";
+    error: string;
+};
+export type CatalogBrowseResult = {
+    projectRoot: string | null;
+    manifest: LoadedManifest | null;
+    manifestStatus: CatalogManifestStatus;
+    issues: LoadIssue[];
+    pipelines: PipelineListing[];
+    tasks: TaskListing[];
+    models: string[];
+    warnings: CatalogBrowseWarning[];
+};
+export type CatalogScanPaths = {
+    pipelinePaths: string[];
+    taskPaths: string[];
+};
+export declare function getCatalogScanPaths(ctx: CatalogContext): Promise<CatalogScanPaths | null>;
+export declare function browseCatalog(invocationCwd: string | StageflowContext): Promise<CatalogBrowseResult>;
+export declare function listPipelinesForContext(ctx: CatalogContext): Promise<PipelineListing[]>;
+export declare function listTasksForContext(ctx: CatalogContext): Promise<TaskListing[]>;
+export declare function listModelsForContext(ctx: CatalogContext): Promise<string[]>;

package/dist/config/browseCatalog.js

@@ -0,0 +1,170 @@
+import path from "node:path";
+import { loadPipeline } from "./loadPipeline.js";
+import { loadTask } from "./loadTask.js";
+import { resolveStageflowContext, } from "../project/resolveStageflowContext.js";
+import { scanCatalogPaths } from "./scanCatalogPaths.js";
+const BAKED_MODEL_IDS = [
+    "anthropic/claude-sonnet-4-5",
+    "cursor/auto",
+    "cursor/composer-2-5",
+];
+function repoRelPath(projectRoot, absPath) {
+    return path.relative(projectRoot, absPath).replace(/\\/g, "/");
+}
+function mapStageListing(stage, source, projectRoot) {
+    const listing = {
+        id: stage.id,
+        ...(stage.gate_kinds ? { gate_kinds: stage.gate_kinds } : {}),
+    };
+    if (source?.kind === "inline") {
+        listing.inline = true;
+    }
+    else if (source?.kind === "file") {
+        listing.uses_path = repoRelPath(projectRoot, source.path);
+    }
+    return listing;
+}
+function bakedModels() {
+    return [...BAKED_MODEL_IDS].sort((a, b) => a.localeCompare(b));
+}
+function catalogReadyFromStageflow(ctx) {
+    return ctx.isGitProject && ctx.manifestStatus === "ok" && ctx.manifest !== null;
+}
+function catalogReady(ctx) {
+    return ctx.manifestStatus === "ok" && ctx.projectRoot !== null && ctx.manifest !== null;
+}
+export async function getCatalogScanPaths(ctx) {
+    if (!catalogReady(ctx)) {
+        return null;
+    }
+    const [pipelinePaths, taskPaths] = await Promise.all([
+        scanCatalogPaths(ctx.manifest, "pipeline"),
+        scanCatalogPaths(ctx.manifest, "task"),
+    ]);
+    return { pipelinePaths, taskPaths };
+}
+async function listTasksFromManifest(projectRoot, manifest, warnings) {
+    const filePaths = await scanCatalogPaths(manifest, "task");
+    const listings = [];
+    for (const filePath of filePaths) {
+        try {
+            const task = await loadTask(filePath);
+            listings.push({
+                path: repoRelPath(projectRoot, filePath),
+                id: task.id,
+                goal: task.goal,
+            });
+        }
+        catch (err) {
+            warnings.push({
+                path: repoRelPath(projectRoot, filePath),
+                kind: "task",
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    listings.sort((a, b) => {
+        const pathCmp = a.path.localeCompare(b.path);
+        if (pathCmp !== 0)
+            return pathCmp;
+        return a.id.localeCompare(b.id);
+    });
+    return listings;
+}
+async function listPipelinesFromManifest(projectRoot, manifest, warnings) {
+    const filePaths = await scanCatalogPaths(manifest, "pipeline");
+    const listings = [];
+    for (const filePath of filePaths) {
+        try {
+            const loaded = await loadPipeline(filePath, { cwd: projectRoot });
+            listings.push({
+                path: repoRelPath(projectRoot, filePath),
+                id: loaded.pipeline.id,
+                stages: loaded.stages.map((stage) => mapStageListing(stage, loaded.stageSources?.[stage.id], projectRoot)),
+            });
+        }
+        catch (err) {
+            warnings.push({
+                path: repoRelPath(projectRoot, filePath),
+                kind: "pipeline",
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    listings.sort((a, b) => {
+        const pathCmp = a.path.localeCompare(b.path);
+        if (pathCmp !== 0)
+            return pathCmp;
+        return a.id.localeCompare(b.id);
+    });
+    return listings;
+}
+async function listModelsFromManifest(projectRoot, manifest) {
+    const models = new Set(BAKED_MODEL_IDS);
+    const filePaths = await scanCatalogPaths(manifest, "pipeline");
+    for (const filePath of filePaths) {
+        try {
+            const loaded = await loadPipeline(filePath, { cwd: projectRoot });
+            for (const stage of loaded.stages) {
+                if (stage.model.trim()) {
+                    models.add(stage.model);
+                }
+            }
+        }
+        catch {
+            // skip invalid pipelines
+        }
+    }
+    return [...models].sort((a, b) => a.localeCompare(b));
+}
+export async function browseCatalog(invocationCwd) {
+    const ctx = typeof invocationCwd === "string"
+        ? await resolveStageflowContext(invocationCwd)
+        : invocationCwd;
+    const base = {
+        projectRoot: ctx.isGitProject ? ctx.projectRoot : null,
+        manifest: ctx.manifest,
+        manifestStatus: ctx.manifestStatus,
+        issues: ctx.manifestIssues,
+    };
+    if (!catalogReadyFromStageflow(ctx)) {
+        return {
+            ...base,
+            pipelines: [],
+            tasks: [],
+            models: bakedModels(),
+            warnings: [],
+        };
+    }
+    const warnings = [];
+    const [pipelines, tasks, models] = await Promise.all([
+        listPipelinesFromManifest(ctx.projectRoot, ctx.manifest, warnings),
+        listTasksFromManifest(ctx.projectRoot, ctx.manifest, warnings),
+        listModelsFromManifest(ctx.projectRoot, ctx.manifest),
+    ]);
+    return {
+        ...base,
+        pipelines,
+        tasks,
+        models,
+        warnings,
+    };
+}
+export async function listPipelinesForContext(ctx) {
+    if (!catalogReady(ctx)) {
+        return [];
+    }
+    return listPipelinesFromManifest(ctx.projectRoot, ctx.manifest, []);
+}
+export async function listTasksForContext(ctx) {
+    if (!catalogReady(ctx)) {
+        return [];
+    }
+    return listTasksFromManifest(ctx.projectRoot, ctx.manifest, []);
+}
+export async function listModelsForContext(ctx) {
+    if (!catalogReady(ctx)) {
+        return bakedModels();
+    }
+    return listModelsFromManifest(ctx.projectRoot, ctx.manifest);
+}