stageflow 0.33.0 → 0.35.0

package/dist/config/updateTrigger.js

@@ -0,0 +1,220 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { parseDocument } from "yaml";
+import { findCatalogTrigger, loadCatalogTriggers, triggerStoreId, } from "./triggerCatalog.js";
+import { resolveCatalogRoots, findCatalogRoot } from "./resolveCatalogRoots.js";
+import { loadTriggerFromYamlOutcome } from "./loadTrigger.js";
+import { catalogContextFromStageflow } from "./resolveCatalogContext.js";
+import { getCatalogScanPaths } from "./browseCatalog.js";
+import { resolveStageflowContext } from "../project/resolveStageflowContext.js";
+import { parseEventField, parseScheduleField, scheduleCronError, triggerReferenceError, } from "./createTrigger.js";
+export function parsePatchTriggerBody(body) {
+    if (!body || typeof body !== "object" || Array.isArray(body)) {
+        return { ok: false, status: 400, error: "Request body must be an object" };
+    }
+    const record = body;
+    const keys = Object.keys(record);
+    if (keys.length !== 1 || keys[0] !== "enabled") {
+        return {
+            ok: false,
+            status: 400,
+            error: "Only enabled is allowed in the request body",
+        };
+    }
+    if (typeof record.enabled !== "boolean") {
+        return { ok: false, status: 400, error: "enabled must be a boolean" };
+    }
+    return { enabled: record.enabled };
+}
+function isPlainObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+export function parsePutTriggerBody(body, triggerId) {
+    if (!isPlainObject(body)) {
+        return { ok: false, status: 400, error: "Request body must be an object" };
+    }
+    if ("id" in body && body.id !== triggerId) {
+        return { ok: false, status: 400, error: "id cannot be changed" };
+    }
+    if (typeof body.pipeline !== "string" || !body.pipeline.trim()) {
+        return { ok: false, status: 400, error: "pipeline is required" };
+    }
+    if (body.task !== undefined &&
+        body.task !== null &&
+        (typeof body.task !== "string" || !body.task.trim())) {
+        return { ok: false, status: 400, error: "task must be a non-empty string" };
+    }
+    if (body.kind !== "manual" && body.kind !== "schedule" && body.kind !== "event") {
+        return {
+            ok: false,
+            status: 400,
+            error: "kind must be one of: manual, schedule, event",
+        };
+    }
+    const scheduleRaw = body.kind === "schedule" ? (body.schedule === null ? undefined : body.schedule) : undefined;
+    const eventRaw = body.kind === "event" ? (body.event === null ? undefined : body.event) : undefined;
+    const schedule = parseScheduleField(scheduleRaw);
+    if (!schedule.ok) {
+        return { ok: false, status: 400, error: schedule.message };
+    }
+    const event = parseEventField(eventRaw);
+    if (!event.ok) {
+        return { ok: false, status: 400, error: event.message };
+    }
+    if (body.kind === "schedule" && schedule.value === undefined) {
+        return { ok: false, status: 400, error: "schedule.cron is required for kind=schedule" };
+    }
+    if (body.kind === "event" && event.value === undefined) {
+        return { ok: false, status: 400, error: "event.source is required for kind=event" };
+    }
+    if (typeof body.enabled !== "boolean") {
+        return { ok: false, status: 400, error: "enabled must be a boolean" };
+    }
+    return {
+        pipeline: body.pipeline,
+        ...(typeof body.task === "string" ? { task: body.task } : {}),
+        kind: body.kind,
+        ...(schedule.value !== undefined ? { schedule: schedule.value } : {}),
+        ...(event.value !== undefined ? { event: event.value } : {}),
+        enabled: body.enabled,
+    };
+}
+function projectRootFilterFromBody(body) {
+    if (!body || typeof body !== "object" || Array.isArray(body))
+        return undefined;
+    const wire = body.project_root;
+    return typeof wire === "string" && wire.trim().length > 0 ? wire.trim() : undefined;
+}
+async function locateWritableTrigger(cwd, store, triggerId, projectRootFilter) {
+    const located = await findCatalogTrigger({
+        store,
+        bootCwd: cwd,
+        triggerId,
+        projectRootFilter,
+    });
+    if (!located.ok) {
+        return {
+            ok: false,
+            status: located.status,
+            error: located.reason,
+            ...(located.status === 409 ? { project_roots: located.project_roots } : {}),
+        };
+    }
+    const roots = await resolveCatalogRoots({ store, bootCwd: cwd });
+    const root = findCatalogRoot(roots, located.match.project_root);
+    if (root?.read_only) {
+        return { ok: false, status: 403, error: "catalog_root_read_only" };
+    }
+    return { ok: true, match: located.match };
+}
+export async function updateTriggerEnabled(cwd, store, triggerId, enabled, options = {}) {
+    const located = await locateWritableTrigger(cwd, store, triggerId, options.projectRootFilter);
+    if (!located.ok) {
+        return located;
+    }
+    const { match } = located;
+    const yamlText = await readFile(match.path, "utf8");
+    const doc = parseDocument(yamlText);
+    if (!doc.contents || typeof doc.contents !== "object") {
+        return { ok: false, status: 500, error: "Trigger YAML must be an object" };
+    }
+    doc.set("enabled", enabled);
+    const patched = doc.toString();
+    const loadOutcome = loadTriggerFromYamlOutcome(patched, match.path);
+    if (!loadOutcome.ok) {
+        return {
+            ok: false,
+            status: 400,
+            error: loadOutcome.issues[0]?.message ?? "Invalid trigger after patch",
+        };
+    }
+    await writeFile(match.path, patched, "utf8");
+    await store.upsertTrigger({
+        id: triggerStoreId(match.project_root, loadOutcome.value.id),
+        definitionRef: match.definition_ref,
+        enabled: loadOutcome.value.enabled,
+    });
+    const items = await loadCatalogTriggers({ store, bootCwd: cwd });
+    const item = items.find((row) => row.id === triggerId && row.project_root === match.project_root);
+    if (!item) {
+        return { ok: false, status: 500, error: "Trigger updated but not listed" };
+    }
+    return { ok: true, trigger: item };
+}
+export async function updateTriggerDefinition(cwd, store, triggerId, input, options = {}) {
+    const located = await locateWritableTrigger(cwd, store, triggerId, options.projectRootFilter);
+    if (!located.ok) {
+        return located;
+    }
+    const { match } = located;
+    const ctx = catalogContextFromStageflow(await resolveStageflowContext(match.rootPath));
+    const scanPaths = await getCatalogScanPaths(ctx);
+    if (!scanPaths) {
+        return { ok: false, status: 404, error: "No Stageflow catalog found" };
+    }
+    const refError = await triggerReferenceError(scanPaths, input.pipeline, input.task);
+    if (refError) {
+        return { ok: false, status: 422, error: refError };
+    }
+    if (input.kind === "schedule") {
+        if (!input.schedule) {
+            return { ok: false, status: 422, error: "schedule.cron is required for kind=schedule" };
+        }
+        const cronError = scheduleCronError(input.schedule);
+        if (cronError) {
+            return { ok: false, status: 422, error: cronError };
+        }
+    }
+    const yamlText = await readFile(match.path, "utf8");
+    const doc = parseDocument(yamlText);
+    if (!doc.contents || typeof doc.contents !== "object") {
+        return { ok: false, status: 500, error: "Trigger YAML must be an object" };
+    }
+    doc.set("pipeline", input.pipeline);
+    if (input.task !== undefined)
+        doc.set("task", input.task);
+    else
+        doc.delete("task");
+    doc.set("kind", input.kind);
+    if (input.kind === "schedule" && input.schedule) {
+        doc.delete("event");
+        doc.set("schedule", {
+            cron: input.schedule.cron,
+            ...(input.schedule.timezone !== undefined ? { timezone: input.schedule.timezone } : {}),
+        });
+    }
+    else if (input.kind === "event" && input.event) {
+        doc.delete("schedule");
+        doc.set("event", {
+            source: input.event.source,
+            ...(input.event.match !== undefined ? { match: input.event.match } : {}),
+            ...(input.event.config !== undefined ? { config: input.event.config } : {}),
+        });
+    }
+    else {
+        doc.delete("schedule");
+        doc.delete("event");
+    }
+    doc.set("enabled", input.enabled);
+    const patched = doc.toString();
+    const loadOutcome = loadTriggerFromYamlOutcome(patched, match.path);
+    if (!loadOutcome.ok) {
+        return {
+            ok: false,
+            status: 400,
+            error: loadOutcome.issues[0]?.message ?? "Invalid trigger after update",
+        };
+    }
+    await writeFile(match.path, patched, "utf8");
+    await store.upsertTrigger({
+        id: triggerStoreId(match.project_root, loadOutcome.value.id),
+        definitionRef: match.definition_ref,
+        enabled: loadOutcome.value.enabled,
+    });
+    const items = await loadCatalogTriggers({ store, bootCwd: cwd });
+    const item = items.find((row) => row.id === triggerId && row.project_root === match.project_root);
+    if (!item) {
+        return { ok: false, status: 500, error: "Trigger updated but not listed" };
+    }
+    return { ok: true, trigger: item };
+}
+export { projectRootFilterFromBody };

package/dist/config/validateCatalog.d.ts

@@ -3,7 +3,7 @@ import type { TriggerFile } from "../types/trigger.js";
 import type { LoadIssue } from "./loadOutcome.js";
 export type ValidationSeverity = "error" | "warning";
 export type ValidationCategory = "pipeline" | "stage" | "catalog" | "task" | "trigger";
-export type ValidationFindingCode = "pipeline.invalid_shape" | "pipeline.dag_error" | "pipeline.missing_stage" | "pipeline.load_error" | "pipeline.string_stage_ref" | "pipeline.stage_uses_inline_conflict" | "pipeline.stage_missing_body" | "pipeline.stage_id_mismatch" | "pipeline.invalid_completion" | "catalog.path_case_mismatch" | "pipeline.invalid_recovery" | "pipeline.include_cycle" | "pipeline.include_invalid" | "pipeline.include_duplicate_stage" | "pipeline.invalid_agent" | "pipeline.invalid_model" | "pipeline.invalid_verify" | "pipeline.io_incompatible" | "pipeline.model_applies" | "pipeline.route_if_invalid" | "pipeline.route_all_gated" | "pipeline.invalid_requires" | "pipeline.requires_conflict" | "stage.invalid_shape" | "stage.invalid_model" | "stage.missing_model" | "stage.invalid_payload_schema" | "stage.invalid_clone_input_schema" | "stage.unresolved_schema_ref" | "stage.invalid_clone_actions" | "stage.invalid_gate_kinds" | "stage.invalid_pre_emit_checks" | "stage.invalid_timeout_ms" | "stage.invalid_skill" | "stage.invalid_mcp" | "stage.invalid_browser" | "stage.invalid_secrets" | "stage.unknown_secret" | "stage.denied_secret" | "stage.invalid_requires" | "stage.invalid_agent" | "stage.invalid_io" | "stage.load_error" | "stage.id_filename_mismatch" | "task.invalid_shape" | "task.load_error" | "task.entry_input_unmet" | "task.binding_conflict" | "task.repository_ref_required" | "task.ref_without_repository" | "task.repository_invalid" | "trigger.invalid_shape" | "trigger.load_error" | "trigger.unknown_pipeline" | "trigger.unknown_task" | "catalog.duplicate_pipeline_id" | "catalog.manifest_missing" | "catalog.manifest_invalid" | "catalog.empty_catalog" | "catalog.manifest_load_error" | "catalog.invalid_mcp" | "catalog.mcp_command_missing" | "catalog.mixed_yaml_dialect" | "catalog.legacy_yaml" | "catalog.stageflow_home_absolute_path";
+export type ValidationFindingCode = "pipeline.invalid_shape" | "pipeline.dag_error" | "pipeline.missing_stage" | "pipeline.load_error" | "pipeline.string_stage_ref" | "pipeline.stage_uses_inline_conflict" | "pipeline.stage_missing_body" | "pipeline.stage_id_mismatch" | "pipeline.stage_wrapper_skill_rejected" | "pipeline.invalid_completion" | "catalog.path_case_mismatch" | "pipeline.invalid_recovery" | "pipeline.include_cycle" | "pipeline.include_invalid" | "pipeline.include_duplicate_stage" | "pipeline.invalid_agent" | "pipeline.invalid_model" | "pipeline.invalid_verify" | "pipeline.io_incompatible" | "pipeline.model_applies" | "pipeline.route_if_invalid" | "pipeline.route_all_gated" | "pipeline.invalid_requires" | "pipeline.requires_conflict" | "stage.invalid_shape" | "stage.invalid_model" | "stage.missing_model" | "stage.invalid_payload_schema" | "stage.invalid_clone_input_schema" | "stage.unresolved_schema_ref" | "stage.invalid_clone_actions" | "stage.invalid_gate_kinds" | "stage.invalid_pre_emit_checks" | "stage.invalid_timeout_ms" | "stage.invalid_skill" | "stage.invalid_mcp" | "stage.invalid_browser" | "stage.invalid_secrets" | "stage.unknown_secret" | "stage.denied_secret" | "stage.invalid_requires" | "stage.invalid_agent" | "stage.invalid_io" | "stage.load_error" | "stage.id_filename_mismatch" | "task.invalid_shape" | "task.load_error" | "task.entry_input_unmet" | "task.binding_conflict" | "task.repository_ref_required" | "task.ref_without_repository" | "task.repository_invalid" | "trigger.invalid_shape" | "trigger.load_error" | "trigger.unknown_pipeline" | "trigger.unknown_task" | "catalog.duplicate_pipeline_id" | "catalog.manifest_missing" | "catalog.manifest_invalid" | "catalog.empty_catalog" | "catalog.manifest_load_error" | "catalog.invalid_mcp" | "catalog.mcp_command_missing" | "catalog.mixed_yaml_dialect" | "catalog.legacy_yaml" | "catalog.stageflow_home_absolute_path";
 export type ValidationFinding = {
     severity: ValidationSeverity;
     code: ValidationFindingCode | string;
@@ -12,8 +12,10 @@ export type ValidationFinding = {
     category: ValidationCategory;
     pipelineId?: string;
     stageId?: string;
+    line?: number;
+    column?: number;
 };
-export type ValidationScope = "full" | "pipeline" | "task" | "trigger";
+export type ValidationScope = "full" | "pipeline" | "task" | "trigger" | "stage";
 export type ValidateCatalogOptions = {
     cwd?: string;
     projectRoot?: string;
@@ -21,6 +23,8 @@ export type ValidateCatalogOptions = {
     pipeline?: string;
     task?: string;
     trigger?: string;
+    stage?: string;
+    stageContent?: string;
     strict?: boolean;
 };
 export type ValidationResult = {

package/dist/config/validateCatalog.js

@@ -1,3 +1,5 @@
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
 import path from "node:path";
 import { globalStageflowHome } from "../project/globalHome.js";
 import { INLINE_PIPELINE_PATH, loadPipelineFromObjectOutcome, loadPipelineOutcome, resolvePipelinePath, } from "./loadPipeline.js";
@@ -122,12 +124,21 @@ function findingCatalog(cwd, absPath, message, code, severity) {
         category: "catalog",
     }, severity);
 }
+function withIssueLocation(finding, issue) {
+    if (issue.line === undefined && issue.column === undefined)
+        return finding;
+    return {
+        ...finding,
+        ...(issue.line !== undefined ? { line: issue.line } : {}),
+        ...(issue.column !== undefined ? { column: issue.column } : {}),
+    };
+}
 export function findingsFromLoadIssues(cwd, absPath, issues) {
     return issues.flatMap((issue) => {
         if (issue.category === "pipeline") {
             if (issue.code === "pipeline.model_applies" || issue.code === "pipeline.route_all_gated") {
                 return [
-                    baseFinding({
+                    withIssueLocation(baseFinding({
                         cwd,
                         absPath,
                         message: issue.message,
@@ -135,26 +146,26 @@ export function findingsFromLoadIssues(cwd, absPath, issues) {
                         category: "pipeline",
                         pipelineId: issue.pipelineId,
                         stageId: issue.stageId,
-                    }, "warning"),
+                    }, "warning"), issue),
                 ];
             }
             return [
-                findingPipelineError(cwd, absPath, issue.message, issue.code, issue.pipelineId, issue.stageId),
+                withIssueLocation(findingPipelineError(cwd, absPath, issue.message, issue.code, issue.pipelineId, issue.stageId), issue),
             ];
         }
         if (issue.category === "stage") {
             return [
-                findingStageError(cwd, absPath, issue.message, issue.code, issue.stageId),
+                withIssueLocation(findingStageError(cwd, absPath, issue.message, issue.code, issue.stageId), issue),
             ];
         }
         if (issue.category === "task") {
             return [
-                findingTaskError(cwd, absPath, issue.message, issue.code),
+                withIssueLocation(findingTaskError(cwd, absPath, issue.message, issue.code), issue),
             ];
         }
         if (issue.category === "trigger") {
             return [
-                findingTriggerError(cwd, absPath, issue.message, issue.code),
+                withIssueLocation(findingTriggerError(cwd, absPath, issue.message, issue.code), issue),
             ];
         }
         if (issue.category === "catalog") {
@@ -164,7 +175,7 @@ export function findingsFromLoadIssues(cwd, absPath, issues) {
                 code === "catalog.legacy_yaml"
                 ? "warning"
                 : "error";
-            return [findingCatalog(cwd, absPath, issue.message, code, severity)];
+            return [withIssueLocation(findingCatalog(cwd, absPath, issue.message, code, severity), issue)];
         }
         return [];
     });
@@ -615,6 +626,30 @@ async function validateSingleTask(invocationCwd, taskArg) {
     }
     return [];
 }
+async function validateSingleStage(invocationCwd, stageArg, stageContent) {
+    const ctx = await resolveCatalogContext(invocationCwd);
+    const relCwd = ctx.projectRoot ?? invocationCwd;
+    const stagePath = path.resolve(invocationCwd, stageArg);
+    if (stageContent === undefined) {
+        return validateStageFile(relCwd, stagePath);
+    }
+    const tmpDir = await mkdtemp(path.join(tmpdir(), "sf-stage-validate-"));
+    const tmpPath = path.join(tmpDir, path.basename(stagePath));
+    try {
+        await writeFile(tmpPath, stageContent, "utf8");
+        const findings = await validateStageFile(relCwd, tmpPath);
+        const displayPath = relPath(relCwd, stagePath);
+        const tmpRel = relPath(relCwd, tmpPath);
+        return findings.map((finding) => finding.path === tmpRel ||
+            finding.path === tmpPath ||
+            finding.path.includes(tmpDir)
+            ? { ...finding, path: displayPath }
+            : finding);
+    }
+    finally {
+        await rm(tmpDir, { recursive: true, force: true });
+    }
+}
 async function validateSingleTrigger(invocationCwd, triggerArg) {
     const ctx = await resolveCatalogContext(invocationCwd);
     const relCwd = ctx.projectRoot ?? invocationCwd;
@@ -647,6 +682,9 @@ export async function validateCatalog(options) {
     if (options.scope === "trigger" && !options.trigger) {
         throw new Error("validateCatalog: trigger is required when scope is \"trigger\"");
     }
+    if (options.scope === "stage" && !options.stage) {
+        throw new Error("validateCatalog: stage is required when scope is \"stage\"");
+    }
     const allFindings = [];
     if (options.scope === "pipeline") {
         return validatePipeline(options.pipeline, {
@@ -662,6 +700,9 @@ export async function validateCatalog(options) {
     else if (options.scope === "trigger") {
         allFindings.push(...(await validateSingleTrigger(cwd, options.trigger)));
     }
+    else if (options.scope === "stage") {
+        allFindings.push(...(await validateSingleStage(cwd, options.stage, options.stageContent)));
+    }
     else {
         allFindings.push(...(await validateManifestAll(cwd)));
     }

package/dist/config/workshopCatalogFilenames.d.ts

@@ -0,0 +1,37 @@
+export declare function normalizePipelineCatalogFilename(pipelineId: string, filename?: string | null): string;
+export declare function taskIdFromDraftTask(task: {
+    filename?: string;
+    body?: Record<string, unknown>;
+}): string;
+export declare function normalizeTaskCatalogFilename(taskId: string, filename?: string | null): string;
+export type DraftTaskArtifact = {
+    filename: string;
+    body: Record<string, unknown>;
+};
+export type DraftPackageFilenames = {
+    pipeline: {
+        id: string;
+    };
+    task?: DraftTaskArtifact;
+};
+export type CatalogYamlKind = "pipeline" | "task" | "other";
+export declare function classifyCatalogYamlDocument(raw: Record<string, unknown>): CatalogYamlKind;
+export declare function legacyBareCatalogFilenames(entityId: string): string[];
+export declare function isMisnamedCatalogBasename(basename: string): boolean;
+export declare function canonicalCatalogBasenameForDocument(raw: Record<string, unknown>, sourceBasename?: string): string | null;
+export type WorkshopCatalogRepairMove = {
+    from: string;
+    to: string;
+};
+export type WorkshopCatalogRepairResult = {
+    renamed: WorkshopCatalogRepairMove[];
+    removed: string[];
+};
+export declare function reconcileWorkshopCatalogFilenames(pipelineId: string, taskId?: string | null, canonicalPipelineBasename?: string, canonicalTaskBasename?: string | null): {
+    renameCandidates: WorkshopCatalogRepairMove[];
+    removeCandidates: string[];
+};
+export declare function normalizeDraftCatalogFilenames<T extends DraftPackageFilenames>(draft: T, pipelineFilename?: string | null): {
+    draft: T;
+    pipelineFilename: string;
+};

package/dist/config/workshopCatalogFilenames.js

@@ -0,0 +1,125 @@
+const PIPELINE_SUFFIX = ".pipeline.yaml";
+const TASK_SUFFIX = ".task.yaml";
+function basenameOnly(name) {
+    const trimmed = name.trim();
+    const parts = trimmed.split(/[\\/]/);
+    return parts[parts.length - 1]?.trim() || trimmed;
+}
+export function normalizePipelineCatalogFilename(pipelineId, filename) {
+    const id = pipelineId.trim() || "untitled";
+    const base = filename?.trim() ? basenameOnly(filename) : "";
+    if (base.endsWith(PIPELINE_SUFFIX)) {
+        const stem = base.slice(0, -PIPELINE_SUFFIX.length);
+        if (stem === id)
+            return base;
+    }
+    return `${id}${PIPELINE_SUFFIX}`;
+}
+export function taskIdFromDraftTask(task) {
+    const bodyId = task.body?.id;
+    if (typeof bodyId === "string" && bodyId.trim())
+        return bodyId.trim();
+    const base = task.filename?.trim() ? basenameOnly(task.filename) : "";
+    if (!base)
+        return "task";
+    return (base
+        .replace(/\.task\.ya?ml$/i, "")
+        .replace(/\.ya?ml$/i, "")
+        .trim() || "task");
+}
+export function normalizeTaskCatalogFilename(taskId, filename) {
+    const id = taskId.trim() || "task";
+    const base = filename?.trim() ? basenameOnly(filename) : "";
+    if (base.endsWith(TASK_SUFFIX)) {
+        const stem = base.slice(0, -TASK_SUFFIX.length);
+        if (stem === id)
+            return base;
+    }
+    return `${id}${TASK_SUFFIX}`;
+}
+const CATALOG_KIND_SUFFIX_PATTERN = /\.(pipeline|task|trigger)\.ya?ml$/i;
+const BARE_YAML_PATTERN = /\.ya?ml$/i;
+export function classifyCatalogYamlDocument(raw) {
+    if (Array.isArray(raw.stages))
+        return "pipeline";
+    if (typeof raw.goal === "string" || typeof raw.pipeline === "string") {
+        return "task";
+    }
+    return "other";
+}
+export function legacyBareCatalogFilenames(entityId) {
+    const id = entityId.trim();
+    if (!id)
+        return [];
+    return [`${id}.yaml`, `${id}.yml`];
+}
+export function isMisnamedCatalogBasename(basename) {
+    const name = basename.trim();
+    if (!BARE_YAML_PATTERN.test(name))
+        return false;
+    if (!CATALOG_KIND_SUFFIX_PATTERN.test(name))
+        return true;
+    return /\.(pipeline|task)\.yml$/i.test(name);
+}
+export function canonicalCatalogBasenameForDocument(raw, sourceBasename) {
+    const kind = classifyCatalogYamlDocument(raw);
+    const id = raw.id;
+    if (typeof id !== "string" || !id.trim())
+        return null;
+    if (kind === "pipeline")
+        return normalizePipelineCatalogFilename(id);
+    if (kind === "task")
+        return normalizeTaskCatalogFilename(id);
+    if (sourceBasename && CATALOG_KIND_SUFFIX_PATTERN.test(sourceBasename)) {
+        const stem = sourceBasename.replace(/\.ya?ml$/i, "");
+        const kindSuffix = stem.match(/\.(pipeline|task|trigger)$/i)?.[1]?.toLowerCase();
+        if (kindSuffix === "pipeline") {
+            return normalizePipelineCatalogFilename(id);
+        }
+        if (kindSuffix === "task") {
+            return normalizeTaskCatalogFilename(id);
+        }
+    }
+    return null;
+}
+export function reconcileWorkshopCatalogFilenames(pipelineId, taskId, canonicalPipelineBasename, canonicalTaskBasename) {
+    const renameCandidates = [];
+    const removeCandidates = [];
+    const pipelineCanonical = canonicalPipelineBasename?.trim() ||
+        normalizePipelineCatalogFilename(pipelineId);
+    const taskCanonical = taskId?.trim()
+        ? canonicalTaskBasename?.trim() ||
+            normalizeTaskCatalogFilename(taskId)
+        : null;
+    for (const legacy of legacyBareCatalogFilenames(pipelineId)) {
+        if (legacy === pipelineCanonical)
+            continue;
+        removeCandidates.push(legacy);
+    }
+    if (taskId?.trim()) {
+        for (const legacy of legacyBareCatalogFilenames(taskId)) {
+            if (legacy === taskCanonical || legacy === pipelineCanonical)
+                continue;
+            removeCandidates.push(legacy);
+        }
+    }
+    return { renameCandidates, removeCandidates };
+}
+export function normalizeDraftCatalogFilenames(draft, pipelineFilename) {
+    const pipelineFilenameOut = normalizePipelineCatalogFilename(draft.pipeline.id, pipelineFilename);
+    if (!draft.task) {
+        return { draft, pipelineFilename: pipelineFilenameOut };
+    }
+    const taskId = taskIdFromDraftTask(draft.task);
+    const taskFilename = normalizeTaskCatalogFilename(taskId, draft.task.filename);
+    if (taskFilename === draft.task.filename) {
+        return { draft, pipelineFilename: pipelineFilenameOut };
+    }
+    return {
+        draft: {
+            ...draft,
+            task: { ...draft.task, filename: taskFilename },
+        },
+        pipelineFilename: pipelineFilenameOut,
+    };
+}

package/dist/config/workshopCatalogRepair.d.ts

@@ -0,0 +1,7 @@
+import { type WorkshopCatalogRepairResult } from "./workshopCatalogFilenames.js";
+export declare function repairMisnamedWorkshopCatalogFiles(packageDirectory: string): Promise<WorkshopCatalogRepairResult>;
+export declare function reconcileWorkshopCatalogPackageDir(packageDirectory: string, pipelineId: string, taskId?: string | null, options?: {
+    pipelineBasename?: string;
+    taskBasename?: string | null;
+}): Promise<WorkshopCatalogRepairResult>;
+export declare function repairWorkshopCatalogTree(projectRoot: string, relativeDirectories: string[]): Promise<WorkshopCatalogRepairResult>;