stageflow 0.1.0 → 0.3.0

package/dist/config/mergePipelineIncludes.js

@@ -0,0 +1,141 @@
+import path from "node:path";
+import { loadFailure, loadSuccess } from "./loadOutcome.js";
+import { readYamlObject } from "./readYamlObject.js";
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizePath(filePath) {
+    return path.normalize(path.resolve(filePath));
+}
+function formatIncludeCycle(stack, nextPath) {
+    const chain = [...stack, nextPath].map((p) => path.basename(p));
+    return chain.join(" → ");
+}
+async function visitPipelineFile(filePath, stack, idLocations, entries) {
+    const absPath = normalizePath(filePath);
+    if (stack.some((p) => normalizePath(p) === absPath)) {
+        const cycleChain = formatIncludeCycle(stack, absPath);
+        return loadFailure([
+            {
+                code: "pipeline.include_cycle",
+                message: `Include cycle detected: ${cycleChain}`,
+                category: "pipeline",
+            },
+        ]);
+    }
+    let raw;
+    try {
+        raw = await readYamlObject(absPath);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return loadFailure([
+            {
+                code: "pipeline.load_error",
+                message,
+                category: "pipeline",
+            },
+        ]);
+    }
+    const nextStack = [...stack, absPath];
+    if (raw.include !== undefined) {
+        if (!Array.isArray(raw.include)) {
+            return loadFailure([
+                {
+                    code: "pipeline.include_invalid",
+                    message: `Invalid include in ${absPath}: include must be an array`,
+                    category: "pipeline",
+                },
+            ]);
+        }
+        for (let index = 0; index < raw.include.length; index++) {
+            const item = raw.include[index];
+            if (!isPlainObject(item) || typeof item.local !== "string" || !item.local) {
+                return loadFailure([
+                    {
+                        code: "pipeline.include_invalid",
+                        message: `Invalid include entry at index ${index} in ${absPath}: expected { local: "<path>" }`,
+                        category: "pipeline",
+                    },
+                ]);
+            }
+            const includePath = normalizePath(path.resolve(path.dirname(absPath), item.local));
+            const includeResult = await visitPipelineFile(includePath, nextStack, idLocations, entries);
+            if (!includeResult.ok)
+                return includeResult;
+        }
+    }
+    if (Array.isArray(raw.stages)) {
+        for (const entry of raw.stages) {
+            if (isPlainObject(entry)) {
+                const entryId = typeof entry.id === "string" ? entry.id : undefined;
+                if (entryId) {
+                    const priorPath = idLocations.get(entryId);
+                    if (priorPath) {
+                        return loadFailure([
+                            {
+                                code: "pipeline.include_duplicate_stage",
+                                message: `Duplicate stage id "${entryId}" in ${absPath} (also declared in ${priorPath})`,
+                                category: "pipeline",
+                            },
+                        ]);
+                    }
+                    idLocations.set(entryId, absPath);
+                }
+            }
+            entries.push({ raw: entry, declaringPath: absPath });
+        }
+    }
+    return loadSuccess(undefined);
+}
+export async function mergePipelineStages(rootPath) {
+    const absRoot = normalizePath(rootPath);
+    let raw;
+    try {
+        raw = await readYamlObject(absRoot);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return loadFailure([
+            {
+                code: "pipeline.load_error",
+                message,
+                category: "pipeline",
+            },
+        ]);
+    }
+    if (typeof raw.id !== "string" || !raw.id) {
+        return loadFailure([
+            {
+                code: "pipeline.invalid_shape",
+                message: `Invalid pipeline ${absRoot}: id is required`,
+                category: "pipeline",
+            },
+        ]);
+    }
+    if (!Array.isArray(raw.stages)) {
+        return loadFailure([
+            {
+                code: "pipeline.invalid_shape",
+                message: `Invalid pipeline ${absRoot}: stages[] is required`,
+                category: "pipeline",
+            },
+        ]);
+    }
+    const pipelineId = raw.id;
+    const idLocations = new Map();
+    const entries = [];
+    const mergeResult = await visitPipelineFile(absRoot, [], idLocations, entries);
+    if (!mergeResult.ok)
+        return mergeResult;
+    if (entries.length === 0) {
+        return loadFailure([
+            {
+                code: "pipeline.invalid_shape",
+                message: `Invalid pipeline ${absRoot}: stages must be non-empty`,
+                category: "pipeline",
+            },
+        ]);
+    }
+    return loadSuccess({ entries, pipelineId });
+}

package/dist/config/normalizePipelineStageEntry.d.ts

@@ -0,0 +1,16 @@
+import type { NormalizedPipelineStageEntry } from "../types/pipeline.js";
+import { type LoadOutcome } from "./loadOutcome.js";
+import type { RawMergedEntry } from "./mergePipelineIncludes.js";
+export declare function inferIdFromUsesPath(usesPath: string): string | null;
+export declare function normalizePipelineStageEntries(rawEntries: RawMergedEntry[], ctx: {
+    pipelineId: string;
+    path: string;
+}): LoadOutcome<NormalizedPipelineStageEntry[]>;
+export declare function toWiringRefs(entries: NormalizedPipelineStageEntry[]): Array<{
+    id: string;
+    needs?: string;
+    fork?: {
+        select: "one" | "subset";
+        allow_none?: boolean;
+    };
+}>;

package/dist/config/normalizePipelineStageEntry.js

@@ -0,0 +1,186 @@
+import path from "node:path";
+import { loadFailure, loadSuccess } from "./loadOutcome.js";
+import { BODY_KEYS, isAllowedPipelineStageEntryKey, } from "./pipelineStageKeys.js";
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function inferIdFromUsesPath(usesPath) {
+    const base = path.basename(usesPath);
+    if (!base)
+        return null;
+    if (base.endsWith(".stage.yaml")) {
+        const id = base.slice(0, -".stage.yaml".length);
+        return id || null;
+    }
+    if (base.endsWith(".yaml")) {
+        const id = base.slice(0, -".yaml".length);
+        return id || null;
+    }
+    return base;
+}
+function extractBodyRaw(raw) {
+    const body = {};
+    for (const key of Object.keys(raw)) {
+        if (BODY_KEYS.has(key)) {
+            body[key] = raw[key];
+        }
+    }
+    return body;
+}
+function hasBodyKey(raw) {
+    return Object.keys(raw).some((key) => BODY_KEYS.has(key));
+}
+function stringStageRefMessage(index, declaringPath, entry) {
+    const hint = entry
+        ? `bare string stage refs are not supported; use { id: "${entry}", uses: "./${entry}.yaml" } or inline body`
+        : `bare string stage refs are not supported; use { id: "…", uses: "./….yaml" } or inline body`;
+    return `Invalid stage entry at index ${index} in ${declaringPath}: ${hint}`;
+}
+export function normalizePipelineStageEntries(rawEntries, ctx) {
+    const normalized = [];
+    for (let index = 0; index < rawEntries.length; index++) {
+        const { raw, declaringPath } = rawEntries[index];
+        if (typeof raw === "string") {
+            return loadFailure([
+                {
+                    code: "pipeline.string_stage_ref",
+                    message: stringStageRefMessage(index, declaringPath, raw),
+                    category: "pipeline",
+                    pipelineId: ctx.pipelineId,
+                },
+            ]);
+        }
+        if (!isPlainObject(raw)) {
+            return loadFailure([
+                {
+                    code: "pipeline.invalid_shape",
+                    message: `Invalid stage entry at index ${index} in ${declaringPath}: expected object`,
+                    category: "pipeline",
+                    pipelineId: ctx.pipelineId,
+                },
+            ]);
+        }
+        for (const key of Object.keys(raw)) {
+            if (!isAllowedPipelineStageEntryKey(key)) {
+                return loadFailure([
+                    {
+                        code: "pipeline.invalid_shape",
+                        message: `Pipeline ${ctx.pipelineId} (${ctx.path}): invalid stage entry at index ${index}: unknown key "${key}"`,
+                        category: "pipeline",
+                        pipelineId: ctx.pipelineId,
+                    },
+                ]);
+            }
+        }
+        const uses = typeof raw.uses === "string" ? raw.uses : undefined;
+        const hasBody = hasBodyKey(raw);
+        if (uses && hasBody) {
+            return loadFailure([
+                {
+                    code: "pipeline.stage_uses_inline_conflict",
+                    message: `Pipeline ${ctx.pipelineId} (${ctx.path}): stage entry at index ${index} has both uses and inline body fields`,
+                    category: "pipeline",
+                    pipelineId: ctx.pipelineId,
+                },
+            ]);
+        }
+        if (!uses && !hasBody) {
+            const entryLabel = typeof raw.id === "string" ? raw.id : String(index);
+            return loadFailure([
+                {
+                    code: "pipeline.stage_missing_body",
+                    message: `Pipeline ${ctx.pipelineId} (${ctx.path}): stage "${entryLabel}" has no uses: path or inline body`,
+                    category: "pipeline",
+                    pipelineId: ctx.pipelineId,
+                },
+            ]);
+        }
+        let id = typeof raw.id === "string" && raw.id ? raw.id : undefined;
+        if (!id && uses) {
+            const inferred = inferIdFromUsesPath(uses);
+            if (inferred)
+                id = inferred;
+        }
+        if (!id) {
+            return loadFailure([
+                {
+                    code: "pipeline.invalid_shape",
+                    message: `Pipeline ${ctx.pipelineId} (${ctx.path}): invalid stage entry at index ${index}: id must be a non-empty string or inferrable from uses path`,
+                    category: "pipeline",
+                    pipelineId: ctx.pipelineId,
+                },
+            ]);
+        }
+        if (raw.needs !== undefined) {
+            if (Array.isArray(raw.needs)) {
+                return loadFailure([
+                    {
+                        code: "pipeline.dag_error",
+                        message: `Pipeline ${ctx.pipelineId} (${ctx.path}): stage "${id}": needs must be a string, not an array`,
+                        category: "pipeline",
+                        pipelineId: ctx.pipelineId,
+                    },
+                ]);
+            }
+            if (typeof raw.needs !== "string" || !raw.needs) {
+                return loadFailure([
+                    {
+                        code: "pipeline.dag_error",
+                        message: `Pipeline ${ctx.pipelineId} (${ctx.path}): stage "${id}": needs must be a non-empty string`,
+                        category: "pipeline",
+                        pipelineId: ctx.pipelineId,
+                    },
+                ]);
+            }
+        }
+        let forkValue;
+        if (raw.fork !== undefined) {
+            if (!isPlainObject(raw.fork)) {
+                return loadFailure([
+                    {
+                        code: "pipeline.dag_error",
+                        message: `Pipeline ${ctx.pipelineId} (${ctx.path}): stage "${id}": fork must be an object`,
+                        category: "pipeline",
+                        pipelineId: ctx.pipelineId,
+                    },
+                ]);
+            }
+            forkValue = raw.fork;
+        }
+        let body;
+        if (uses) {
+            const absolutePath = path.resolve(path.dirname(declaringPath), uses);
+            body = { kind: "uses", path: uses, absolutePath };
+        }
+        else {
+            body = { kind: "inline", raw: extractBodyRaw(raw) };
+        }
+        const entry = {
+            id,
+            declaringPath,
+            body,
+            ...(typeof raw.needs === "string" ? { needs: raw.needs } : {}),
+            ...(forkValue !== undefined ? { fork: forkValue } : {}),
+        };
+        const priorPath = normalized.find((e) => e.id === id)?.declaringPath;
+        if (priorPath) {
+            return loadFailure([
+                {
+                    code: "pipeline.include_duplicate_stage",
+                    message: `Duplicate stage id "${id}" in ${declaringPath} (also declared in ${priorPath})`,
+                    category: "pipeline",
+                    pipelineId: ctx.pipelineId,
+                },
+            ]);
+        }
+        normalized.push(entry);
+    }
+    return loadSuccess(normalized);
+}
+export function toWiringRefs(entries) {
+    return entries.map((entry) => ({
+        id: entry.id,
+        ...(entry.needs !== undefined ? { needs: entry.needs } : {}),
+        ...(entry.fork !== undefined ? { fork: entry.fork } : {}),
+    }));
+}

package/dist/config/pipelineStageKeys.d.ts

@@ -0,0 +1,4 @@
+export declare const WIRING_KEYS: Set<string>;
+export declare const BODY_KEYS: Set<string>;
+export declare function isPipelineStageBodyKey(key: string): boolean;
+export declare function isAllowedPipelineStageEntryKey(key: string): boolean;

package/dist/config/pipelineStageKeys.js

@@ -0,0 +1,14 @@
+export const WIRING_KEYS = new Set(["id", "needs", "fork", "uses"]);
+export const BODY_KEYS = new Set([
+    "system_prompt",
+    "model",
+    "payload_schema",
+    "gate_kinds",
+    "skill",
+]);
+export function isPipelineStageBodyKey(key) {
+    return BODY_KEYS.has(key);
+}
+export function isAllowedPipelineStageEntryKey(key) {
+    return WIRING_KEYS.has(key) || BODY_KEYS.has(key);
+}

package/dist/config/resolveCatalogContext.d.ts

@@ -0,0 +1,13 @@
+import type { LoadedManifest } from "../types/stageflowManifest.js";
+import type { LoadIssue } from "./loadOutcome.js";
+import { type CatalogManifestStatus, type StageflowContext } from "../project/resolveStageflowContext.js";
+export type { CatalogManifestStatus };
+export type CatalogContext = {
+    projectRoot: string | null;
+    manifest: LoadedManifest | null;
+    manifestStatus: CatalogManifestStatus;
+    issues: LoadIssue[];
+};
+export declare function catalogContextFromStageflow(ctx: StageflowContext): CatalogContext;
+/** @deprecated Prefer resolveStageflowContext */
+export declare function resolveCatalogContext(invocationCwd: string): Promise<CatalogContext>;

package/dist/config/resolveCatalogContext.js

@@ -0,0 +1,13 @@
+import { resolveStageflowContext, } from "../project/resolveStageflowContext.js";
+export function catalogContextFromStageflow(ctx) {
+    return {
+        projectRoot: ctx.isGitProject ? ctx.projectRoot : null,
+        manifest: ctx.manifest,
+        manifestStatus: ctx.manifestStatus,
+        issues: ctx.manifestIssues,
+    };
+}
+/** @deprecated Prefer resolveStageflowContext */
+export async function resolveCatalogContext(invocationCwd) {
+    return catalogContextFromStageflow(await resolveStageflowContext(invocationCwd));
+}

package/dist/config/resolveForkEmitContext.d.ts

@@ -0,0 +1,3 @@
+import type { ForkEmitContext } from "../types/forkChoice.js";
+import type { ResolvedPipelineDag } from "../types/pipeline.js";
+export declare function resolveForkEmitContext(dag: ResolvedPipelineDag, stageId: string): ForkEmitContext | undefined;

package/dist/config/resolveForkEmitContext.js

@@ -0,0 +1,12 @@
+export function resolveForkEmitContext(dag, stageId) {
+    const dagNode = dag.nodes.find((n) => n.id === stageId);
+    if (!dagNode?.fork)
+        return undefined;
+    return {
+        immediateSuccessorIds: dag.childrenOf[stageId] ?? [],
+        forkShape: {
+            cardinality: dagNode.fork.select,
+            allowNone: dagNode.fork.allow_none,
+        },
+    };
+}

package/dist/config/resolvePipelineDag.d.ts

@@ -1,9 +1,13 @@
-import type { PipelineStageYamlEntry, ResolvedPipelineDag } from "../types/pipeline.js";
+import type { PipelineStageRef, PipelineStageYamlEntry, ResolvedPipelineDag } from "../types/pipeline.js";
 export type ResolvePipelineDagContext = {
     pipelineId: string;
     path: string;
 };
 export declare function parsePipelineStageEntries(raw: unknown, ctx: ResolvePipelineDagContext): PipelineStageYamlEntry[];
+export declare function resolvePipelineDagFromRefs(refs: PipelineStageRef[], ctx: ResolvePipelineDagContext): {
+    stages: string[];
+    dag: ResolvedPipelineDag;
+};
 export declare function resolvePipelineDag(rawStages: unknown, ctx: ResolvePipelineDagContext): {
     stages: string[];
     dag: ResolvedPipelineDag;

package/dist/config/resolvePipelineDag.js

@@ -1,4 +1,5 @@
-const ALLOWED_STAGE_REF_KEYS = new Set(["id", "needs"]);
+import { isAllowedPipelineStageEntryKey } from "./pipelineStageKeys.js";
+const ALLOWED_FORK_KEYS = new Set(["select", "allow_none"]);
 function pipelineLabel(ctx) {
     return `Pipeline ${ctx.pipelineId} (${ctx.path})`;
 }
@@ -19,26 +20,37 @@ export function parsePipelineStageEntries(raw, ctx) {
     for (let index = 0; index < raw.length; index++) {
         const entry = raw[index];
         if (typeof entry === "string") {
-            if (!entry) {
-                throw new Error(formatError(ctx, `invalid stage entry at index ${index}: stage id must be a non-empty string`));
-            }
-            entries.push(entry);
-            continue;
+            const hint = entry
+                ? `invalid stage entry at index ${index}: bare string stage refs are not supported; use { id: "${entry}", uses: "./${entry}.yaml" } or inline body`
+                : `invalid stage entry at index ${index}: bare string stage refs are not supported; use { id: "…", uses: "./….yaml" } or inline body`;
+            throw new Error(formatError(ctx, hint));
         }
         if (!isPlainObject(entry)) {
             throw new Error(formatError(ctx, `invalid stage entry at index ${index}`));
         }
         const keys = Object.keys(entry);
         for (const key of keys) {
-            if (!ALLOWED_STAGE_REF_KEYS.has(key)) {
+            if (!isAllowedPipelineStageEntryKey(key)) {
                 throw new Error(formatError(ctx, `invalid stage entry "${String(entry.id ?? index)}": unknown key "${key}"`));
             }
         }
         if (typeof entry.id !== "string" || !entry.id) {
             throw new Error(formatError(ctx, `invalid stage entry at index ${index}: id must be a non-empty string`));
         }
+        let forkValue;
+        if (entry.fork !== undefined) {
+            if (!isPlainObject(entry.fork)) {
+                throw new Error(formatError(ctx, `stage "${entry.id}": fork must be an object`));
+            }
+            for (const fk of Object.keys(entry.fork)) {
+                if (!ALLOWED_FORK_KEYS.has(fk)) {
+                    throw new Error(formatError(ctx, `stage "${entry.id}": fork: unknown key "${fk}"`));
+                }
+            }
+            forkValue = entry.fork;
+        }
         if (entry.needs === undefined) {
-            entries.push({ id: entry.id });
+            entries.push(forkValue !== undefined ? { id: entry.id, fork: forkValue } : { id: entry.id });
             continue;
         }
         if (Array.isArray(entry.needs)) {
@@ -50,29 +62,19 @@ export function parsePipelineStageEntries(raw, ctx) {
         if (typeof entry.needs !== "string" || !entry.needs) {
             throw new Error(formatError(ctx, `stage "${entry.id}": needs must be a non-empty string`));
         }
-        entries.push({ id: entry.id, needs: entry.needs });
+        entries.push(forkValue !== undefined
+            ? { id: entry.id, needs: entry.needs, fork: forkValue }
+            : { id: entry.id, needs: entry.needs });
     }
     return entries;
 }
 function normalizeToEdges(entries) {
-    const edges = [];
-    for (let index = 0; index < entries.length; index++) {
-        const entry = entries[index];
-        if (typeof entry === "string") {
-            edges.push({
-                id: entry,
-                needs: index > 0 ? entries[index - 1] : null,
-                stageIndex: index,
-            });
-            continue;
-        }
-        edges.push({
-            id: entry.id,
-            needs: entry.needs ?? null,
-            stageIndex: index,
-        });
-    }
-    return edges;
+    return entries.map((entry, index) => ({
+        id: entry.id,
+        needs: entry.needs ?? null,
+        stageIndex: index,
+        ...(entry.fork !== undefined ? { fork: entry.fork } : {}),
+    }));
 }
 function detectDuplicateIds(edges, ctx) {
     const seen = new Set();
@@ -160,7 +162,7 @@ function topologicalSort(edges) {
         indegree.set(edge.id, (indegree.get(edge.id) ?? 0) + 1);
         children.get(edge.needs)?.push(edge.id);
     }
-    for (const [parent, childIds] of children) {
+    for (const [, childIds] of children) {
         childIds.sort((a, b) => (byId.get(a)?.stageIndex ?? 0) - (byId.get(b)?.stageIndex ?? 0));
     }
     const roots = edges
@@ -208,12 +210,26 @@ function buildResolvedPipelineDag(edges) {
         needs: edge.needs,
         ancestors: ancestorsById.get(edge.id) ?? [],
         stageIndex: edge.stageIndex,
+        ...(edge.fork !== undefined
+            ? { fork: { select: edge.fork.select, allow_none: edge.fork.allow_none ?? false } }
+            : {}),
     }));
     return { nodes, roots, childrenOf };
 }
-export function resolvePipelineDag(rawStages, ctx) {
-    const entries = parsePipelineStageEntries(rawStages, ctx);
-    const edges = normalizeToEdges(entries);
+function validateForkFields(edges, dag, ctx) {
+    for (const edge of edges) {
+        if (!edge.fork)
+            continue;
+        if (edge.fork.select !== "one" && edge.fork.select !== "subset") {
+            throw new Error(formatError(ctx, `stage "${edge.id}": fork.select must be "one" or "subset"${edge.fork.select === undefined ? " (missing)" : `, got "${String(edge.fork.select)}"`}`));
+        }
+        if ((dag.childrenOf[edge.id] ?? []).length === 0) {
+            throw new Error(formatError(ctx, `fork on stage "${edge.id}": no children in the DAG`));
+        }
+    }
+}
+export function resolvePipelineDagFromRefs(refs, ctx) {
+    const edges = normalizeToEdges(refs);
     detectDuplicateIds(edges, ctx);
     validateNeedsTargets(edges, ctx);
     detectCycle(edges, ctx);
@@ -222,8 +238,13 @@ export function resolvePipelineDag(rawStages, ctx) {
         .sort((a, b) => a.stageIndex - b.stageIndex)
         .map((edge) => edge.id);
     const dag = buildResolvedPipelineDag(edges);
+    validateForkFields(edges, dag, ctx);
     return { stages, dag };
 }
+export function resolvePipelineDag(rawStages, ctx) {
+    const entries = parsePipelineStageEntries(rawStages, ctx);
+    return resolvePipelineDagFromRefs(entries, ctx);
+}
 export function areResolvedDagsEquivalent(a, b) {
     const nodeIdsA = new Set(a.nodes.map((node) => node.id));
     const nodeIdsB = new Set(b.nodes.map((node) => node.id));
@@ -256,16 +277,13 @@ export function extractPipelineStageIds(rawStages) {
     const stageIds = [];
     for (const entry of rawStages) {
         if (typeof entry === "string") {
-            if (!entry)
-                return null;
-            stageIds.push(entry);
-            continue;
+            return null;
         }
         if (!isPlainObject(entry))
             return null;
         const keys = Object.keys(entry);
         for (const key of keys) {
-            if (!ALLOWED_STAGE_REF_KEYS.has(key))
+            if (!isAllowedPipelineStageEntryKey(key))
                 return null;
         }
         if (typeof entry.id !== "string" || !entry.id)

package/dist/config/scanCatalogPaths.d.ts

@@ -0,0 +1,4 @@
+import type { LoadedManifest } from "../types/stageflowManifest.js";
+export type CatalogPathKind = "pipeline" | "task";
+export declare function isExcluded(repoRelPath: string, exclude: string[] | undefined): boolean;
+export declare function scanCatalogPaths(manifest: LoadedManifest, kind: CatalogPathKind): Promise<string[]>;

package/dist/config/scanCatalogPaths.js

@@ -0,0 +1,83 @@
+import { readdir, stat } from "node:fs/promises";
+import path from "node:path";
+function normalizeRepoRel(repoRelPath) {
+    return repoRelPath.replace(/\\/g, "/").replace(/^\.\/+/, "");
+}
+export function isExcluded(repoRelPath, exclude) {
+    if (!exclude || exclude.length === 0) {
+        return false;
+    }
+    const normalized = normalizeRepoRel(repoRelPath);
+    for (const entry of exclude) {
+        const prefix = normalizeRepoRel(entry);
+        if (normalized === prefix || normalized.startsWith(`${prefix}/`)) {
+            return true;
+        }
+    }
+    return false;
+}
+function globPatternToRegExp(pattern) {
+    const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+    return new RegExp(`^${escaped}$`);
+}
+function matchesPattern(basename, pattern) {
+    return globPatternToRegExp(pattern).test(basename);
+}
+async function walkDirectory(absDir) {
+    const files = [];
+    let entries;
+    try {
+        entries = await readdir(absDir, { withFileTypes: true, recursive: true });
+    }
+    catch {
+        return files;
+    }
+    for (const entry of entries) {
+        if (!entry.isFile())
+            continue;
+        const parentDir = entry.parentPath ?? absDir;
+        files.push(path.join(parentDir, entry.name));
+    }
+    return files;
+}
+async function expandCatalogEntry(projectRoot, entry, kind, pattern) {
+    const absPath = path.join(projectRoot, entry);
+    let entryStat;
+    try {
+        entryStat = await stat(absPath);
+    }
+    catch {
+        return [];
+    }
+    if (entryStat.isFile()) {
+        return [absPath];
+    }
+    if (!entryStat.isDirectory()) {
+        return [];
+    }
+    const files = await walkDirectory(absPath);
+    return files.filter((filePath) => matchesPattern(path.basename(filePath), pattern));
+}
+export async function scanCatalogPaths(manifest, kind) {
+    const { projectRoot, manifest: doc, patterns } = manifest;
+    const entries = kind === "pipeline" ? doc.catalog.pipelines : doc.catalog.tasks;
+    const pattern = kind === "pipeline" ? patterns.pipeline : patterns.task;
+    const exclude = doc.catalog.exclude;
+    const seen = new Set();
+    const resolved = [];
+    for (const entry of entries) {
+        const absPaths = await expandCatalogEntry(projectRoot, entry, kind, pattern);
+        for (const absPath of absPaths) {
+            const normalized = path.resolve(absPath);
+            if (seen.has(normalized))
+                continue;
+            const repoRel = normalizeRepoRel(path.relative(projectRoot, normalized));
+            if (isExcluded(repoRel, exclude))
+                continue;
+            seen.add(normalized);
+            resolved.push(normalized);
+        }
+    }
+    resolved.sort((a, b) => a.localeCompare(b));
+    return resolved;
+}