@interf/compiler 0.9.1 → 0.9.4

package/dist/packages/method-package/local-methods.js

@@ -0,0 +1,466 @@
+import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync, } from "node:fs";
+import { dirname, join, relative } from "node:path";
+import { z } from "zod";
+import { listFilesRecursive } from "../shared/filesystem.js";
+import { warnInterf } from "../shared/logger.js";
+import { readJsonFileUnchecked, readJsonFileWithSchema } from "../shared/parse.js";
+import { isMarkdownFile } from "../shared/file-types.js";
+import { MethodCompilerApiSchema, RuntimeStageAcceptanceSchema, MethodPurposeSchema, MethodStageZoneAccessSchema, } from "../compiler/lib/schema.js";
+import { RuntimeContractTypeSchema, InterfIdPattern, } from "../contracts/lib/schema.js";
+import { listBuiltinCompiledZoneSpecs, } from "./builtin-compiled-method.js";
+import { CONTEXT_INTERFACE_FILE, ContextInterfaceSchema, contextInterfaceExists, contextInterfaceFilePath, readContextInterface, MethodInputSpecSchema, writeContextInterface, } from "./context-interface.js";
+import { PACKAGE_ROOT } from "./lib/package-root.js";
+import { mergeStagePolicyNotesForStages } from "./method-stage-policy.js";
+const LocalMethodStageDefinitionSchema = z.object({
+    id: z.string().regex(InterfIdPattern),
+    label: z.string().min(1),
+    contract_type: RuntimeContractTypeSchema,
+    skill_dir: z.string().regex(InterfIdPattern).optional(),
+    description: z.string().min(1).optional(),
+    reads: MethodStageZoneAccessSchema,
+    writes: MethodStageZoneAccessSchema,
+    acceptance: RuntimeStageAcceptanceSchema.optional(),
+});
+const LocalMethodDefinitionSchema = z.object({
+    id: z.string().regex(InterfIdPattern),
+    type: z.literal("compiled"),
+    compiler_api: MethodCompilerApiSchema.optional(),
+    purpose: MethodPurposeSchema.optional(),
+    inputs: z.array(MethodInputSpecSchema).min(1).optional(),
+    label: z.string().min(1),
+    hint: z.string().min(1),
+    stages: z.array(LocalMethodStageDefinitionSchema).min(1).optional(),
+    stage_policy_notes: z.record(z.string(), z.array(z.string())).optional(),
+});
+function methodRootPath(sourcePath) {
+    return join(sourcePath, "interf", "methods");
+}
+function builtinMethodRootPath(methodId) {
+    return join(PACKAGE_ROOT, "builtin-methods", methodId);
+}
+export function methodDefinitionPath(sourcePath, id) {
+    return join(methodRootPath(sourcePath), id);
+}
+function isSupportedMethodStarterDocPath(relativePath) {
+    if (relativePath === "README.md")
+        return true;
+    if (relativePath.startsWith("improve/"))
+        return true;
+    if (relativePath.startsWith("use/query/"))
+        return true;
+    if (relativePath.startsWith("compile/stages/"))
+        return true;
+    return false;
+}
+function collectStarterDocs(dirPath) {
+    return listFilesRecursive(dirPath, isMarkdownFile)
+        .map((filePath) => relative(dirPath, filePath).replaceAll("\\", "/"))
+        .filter((relativePath) => isSupportedMethodStarterDocPath(relativePath))
+        .map((relativePath) => ({
+        relativePath,
+        content: readFileSync(join(dirPath, relativePath), "utf8"),
+    }))
+        .sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+}
+function methodPackageCopyPaths(dirPath) {
+    return [
+        "method.json",
+        CONTEXT_INTERFACE_FILE,
+        ...collectStarterDocs(dirPath).map((doc) => doc.relativePath),
+    ];
+}
+function copyRelativeFile(sourceRoot, targetRoot, relativePath) {
+    const sourcePath = join(sourceRoot, relativePath);
+    if (!existsSync(sourcePath))
+        return;
+    const targetPath = join(targetRoot, relativePath);
+    mkdirSync(dirname(targetPath), { recursive: true });
+    cpSync(sourcePath, targetPath, { force: true });
+}
+function copyMethodPackageFiles(sourceMethodPath, targetMethodPath) {
+    rmSync(targetMethodPath, { recursive: true, force: true });
+    mkdirSync(targetMethodPath, { recursive: true });
+    for (const relativePath of methodPackageCopyPaths(sourceMethodPath)) {
+        copyRelativeFile(sourceMethodPath, targetMethodPath, relativePath);
+    }
+}
+export function loadMethodDefinitionFromDir(dirPath) {
+    const methodPath = existsSync(join(dirPath, "method.json"))
+        ? join(dirPath, "method.json")
+        : null;
+    if (!methodPath)
+        return null;
+    const definition = readJsonFileWithSchema(methodPath, "local Method definition", LocalMethodDefinitionSchema);
+    if (!definition)
+        return null;
+    const methodSchema = readContextInterface(dirPath);
+    if (!methodSchema)
+        return null;
+    if (definition.type !== "compiled") {
+        warnInterf(`Warning: local Method definition at ${methodPath} has unexpected type "${definition.type}".`);
+        return null;
+    }
+    return {
+        ...definition,
+        method_schema: methodSchema,
+        starter_docs: collectStarterDocs(dirPath),
+        directoryPath: dirPath,
+        methodPath,
+        methodSchemaPath: contextInterfaceFilePath(dirPath),
+    };
+}
+export function listLocalMethodDefinitions(sourcePath) {
+    const definitions = new Map();
+    const root = methodRootPath(sourcePath);
+    if (existsSync(root)) {
+        for (const entryPath of readdirSync(root).map((entry) => join(root, entry))) {
+            try {
+                if (!statSync(entryPath).isDirectory())
+                    continue;
+            }
+            catch {
+                continue;
+            }
+            const definition = loadMethodDefinitionFromDir(entryPath);
+            if (definition)
+                definitions.set(definition.id, definition);
+        }
+    }
+    return [...definitions.values()].sort((a, b) => a.label.localeCompare(b.label));
+}
+export function loadLocalMethodDefinition(sourcePath, id) {
+    return loadMethodDefinitionFromDir(methodDefinitionPath(sourcePath, id));
+}
+export function resolveMethodPackageSourcePath(sourcePath, methodId) {
+    const localPath = methodDefinitionPath(sourcePath, methodId);
+    if (loadMethodDefinitionFromDir(localPath))
+        return localPath;
+    const builtinPath = builtinMethodRootPath(methodId);
+    if (loadMethodDefinitionFromDir(builtinPath))
+        return builtinPath;
+    return null;
+}
+export function seedLocalDefaultMethod(options) {
+    const methodId = "interf-default";
+    const targetPath = methodDefinitionPath(options.sourcePath, methodId);
+    if (existsSync(join(targetPath, "method.json"))) {
+        return { methodId, targetPath, alreadyExisted: true };
+    }
+    const builtinInterfPath = builtinMethodRootPath(methodId);
+    if (!existsSync(join(builtinInterfPath, "method.json"))) {
+        throw new Error(`Built-in "${methodId}" Method package not found at ${builtinInterfPath}.`);
+    }
+    copyMethodPackageDirectory(builtinInterfPath, targetPath);
+    patchMethodPackageMetadata(targetPath, {
+        id: methodId,
+        label: "Built-in Interf Method",
+        hint: "Built-in file-processing Method: summarize source-grounded evidence, structure cross-file connections, and shape portable context around the saved readiness checks.",
+    });
+    return { methodId, targetPath, alreadyExisted: false };
+}
+export function isMethodId(value) {
+    return InterfIdPattern.test(value);
+}
+function readMethodJsonObject(dirPath) {
+    const methodPath = join(dirPath, "method.json");
+    const raw = readJsonFileUnchecked(methodPath, "Method package");
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        throw new Error(`Method package at ${dirPath} is missing a valid method.json.`);
+    }
+    return { ...raw };
+}
+export function patchMethodPackageMetadata(dirPath, options = {}) {
+    const methodPath = join(dirPath, "method.json");
+    const methodJson = readMethodJsonObject(dirPath);
+    const normalizedStages = Array.isArray(methodJson.stages) && methodJson.stages.length > 0
+        ? methodJson.stages
+        : null;
+    if (!normalizedStages) {
+        throw new Error(`Cannot patch Method package at ${dirPath}: method.json must declare explicit stages before it can be copied or rewritten.`);
+    }
+    const nextMethodJson = {
+        ...methodJson,
+        type: "compiled",
+        compiler_api: methodJson.compiler_api ?? {
+            kind: "compiled",
+            version: 1,
+        },
+        stages: normalizedStages,
+        ...(options.id ? { id: options.id } : {}),
+        ...(options.inputs && options.inputs.length > 0 ? { inputs: options.inputs } : {}),
+        ...(options.label ? { label: options.label } : {}),
+        ...(options.hint ? { hint: options.hint } : {}),
+    };
+    const mergedStagePolicyNotes = mergeStagePolicyNotesForStages(normalizedStages, methodJson.stage_policy_notes, options.stagePolicyNotes);
+    if (mergedStagePolicyNotes) {
+        nextMethodJson.stage_policy_notes = mergedStagePolicyNotes;
+    }
+    else {
+        delete nextMethodJson.stage_policy_notes;
+    }
+    writeFileSync(methodPath, JSON.stringify(nextMethodJson, null, 2) + "\n");
+    const schemaLabel = `${String(nextMethodJson.label ?? methodJson.label ?? options.id ?? "Method")} Method schema`;
+    const existingSchema = readContextInterface(dirPath);
+    if (!existingSchema) {
+        throw new Error(`Cannot patch Method package at ${dirPath}: missing ${CONTEXT_INTERFACE_FILE}. Restore or reseed the package instead of regenerating a schema from method.json.`);
+    }
+    writeContextInterface(dirPath, {
+        ...existingSchema,
+        label: schemaLabel,
+    });
+}
+function collectMethodPackageStructureIssues(dirPath, stages) {
+    const issues = [];
+    const methodPath = join(dirPath, "method.json");
+    if (!existsSync(methodPath))
+        issues.push("missing method.json");
+    if (!contextInterfaceExists(dirPath))
+        issues.push("missing method.schema.json");
+    if (!existsSync(join(dirPath, "README.md")))
+        issues.push("missing README.md");
+    if (!existsSync(join(dirPath, "improve", "SKILL.md")))
+        issues.push("missing improve/SKILL.md");
+    if (!existsSync(join(dirPath, "use", "query", "SKILL.md")))
+        issues.push("missing use/query/SKILL.md");
+    if (!stages)
+        return issues;
+    for (const stage of stages) {
+        const skillDir = typeof stage.skill_dir === "string" && stage.skill_dir.trim().length > 0
+            ? stage.skill_dir
+            : stage.id;
+        if (!existsSync(join(dirPath, "compile", "stages", skillDir, "SKILL.md"))) {
+            issues.push(`missing compile/stages/${skillDir}/SKILL.md`);
+        }
+    }
+    return issues;
+}
+function collectMethodStageSkillIssues(dirPath, stages) {
+    if (!stages)
+        return [];
+    const issues = [];
+    for (const stage of stages) {
+        const skillDir = typeof stage.skill_dir === "string" && stage.skill_dir.trim().length > 0
+            ? stage.skill_dir
+            : stage.id;
+        if (!existsSync(join(dirPath, "compile", "stages", skillDir, "SKILL.md"))) {
+            issues.push(`missing compile/stages/${skillDir}/SKILL.md`);
+        }
+    }
+    return issues;
+}
+export function describeMethodPackagePortability(dirPath) {
+    const issues = collectMethodPackageStructureIssues(dirPath, null);
+    if (issues.length > 0)
+        return issues;
+    let methodJson;
+    try {
+        methodJson = readMethodJsonObject(dirPath);
+    }
+    catch (error) {
+        issues.push(error instanceof Error ? error.message : String(error));
+        return issues;
+    }
+    const parsed = LocalMethodDefinitionSchema.safeParse(methodJson);
+    if (!parsed.success) {
+        issues.push(...parsed.error.issues.map((issue) => issue.path.length > 0
+            ? `method.json ${issue.path.join(".")}: ${issue.message}`
+            : `method.json: ${issue.message}`));
+        return issues;
+    }
+    if (!parsed.data.stages || parsed.data.stages.length === 0) {
+        issues.push("method.json must declare explicit stages for a portable Method package");
+        return issues;
+    }
+    return [
+        ...issues,
+        ...collectMethodStageSkillIssues(dirPath, parsed.data.stages ?? null),
+    ];
+}
+export function isPortableMethodPackage(dirPath) {
+    return describeMethodPackagePortability(dirPath).length === 0;
+}
+export function copyMethodPackageDirectory(sourceMethodPath, targetMethodPath) {
+    const portabilityIssues = describeMethodPackagePortability(sourceMethodPath);
+    if (portabilityIssues.length > 0) {
+        throw new Error(`Method package at ${sourceMethodPath} is not directly copyable: ${portabilityIssues.join("; ")}.`);
+    }
+    mkdirSync(dirname(targetMethodPath), { recursive: true });
+    copyMethodPackageFiles(sourceMethodPath, targetMethodPath);
+}
+export function validateMethodPackage(dirPath) {
+    const methodPath = join(dirPath, "method.json");
+    if (!existsSync(methodPath)) {
+        return {
+            ok: false,
+            summary: `No method.json found at ${dirPath}`,
+            errors: ["Missing method.json"],
+            counts: {},
+        };
+    }
+    const raw = readJsonFileUnchecked(methodPath, "Method package");
+    if (!raw) {
+        return {
+            ok: false,
+            summary: `Failed to parse method.json at ${methodPath}`,
+            errors: ["Invalid JSON in method.json"],
+            counts: {},
+        };
+    }
+    const parsed = LocalMethodDefinitionSchema.safeParse(raw);
+    if (!parsed.success) {
+        const issues = parsed.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`);
+        return {
+            ok: false,
+            summary: `method.json failed validation: ${issues.length} issue(s)`,
+            errors: issues,
+            counts: {},
+        };
+    }
+    const def = parsed.data;
+    const errors = [];
+    if (!def.stages || def.stages.length === 0) {
+        errors.push("method.json must declare explicit stages.");
+    }
+    if (def.stage_policy_notes && def.stages) {
+        const stageIds = new Set(def.stages.map((stage) => stage.id));
+        for (const stageId of Object.keys(def.stage_policy_notes)) {
+            if (!stageIds.has(stageId)) {
+                errors.push(`method.json stage_policy_notes references unknown stage "${stageId}".`);
+            }
+        }
+    }
+    for (const issue of collectMethodPackageStructureIssues(dirPath, def.stages ?? null)) {
+        const formatted = issue.startsWith("missing ")
+            ? `Missing ${issue.slice("missing ".length)}.`
+            : issue;
+        errors.push(formatted);
+    }
+    const methodSchema = readContextInterface(dirPath);
+    if (!methodSchema) {
+        errors.push(...describeContextInterfaceValidationIssues(dirPath));
+    }
+    if (methodSchema) {
+        const stages = def.stages ?? [];
+        const stageIds = new Set(stages.map((stage) => stage.id));
+        const seenPaths = new Map();
+        const seenZoneIds = new Set();
+        const zoneById = new Map(methodSchema.zones.map((zone) => [zone.id, zone]));
+        const normalizedParts = (value) => value.replaceAll("\\", "/").split("/").filter(Boolean);
+        const hasOverlappingPath = (value, other) => {
+            const a = normalizedParts(value);
+            const b = normalizedParts(other);
+            const shorter = a.length <= b.length ? a : b;
+            const longer = a.length <= b.length ? b : a;
+            return shorter.every((part, index) => longer[index] === part);
+        };
+        for (const zone of methodSchema.zones) {
+            if (seenZoneIds.has(zone.id)) {
+                errors.push(`method.schema.json repeats zone id "${zone.id}".`);
+            }
+            seenZoneIds.add(zone.id);
+            const existingPathOwner = seenPaths.get(zone.path);
+            if (existingPathOwner) {
+                errors.push(`method.schema.json repeats zone path "${zone.path}".`);
+            }
+            for (const [existingPath, existingZoneId] of seenPaths.entries()) {
+                if (existingPath === zone.path)
+                    continue;
+                if (hasOverlappingPath(zone.path, existingPath)) {
+                    errors.push(`method.schema.json zones "${zone.id}" and "${existingZoneId}" overlap on path "${zone.path}" / "${existingPath}".`);
+                }
+            }
+            seenPaths.set(zone.path, zone.id);
+            if ((zone.role === "input" || zone.role === "runtime") && zone.owned_by.length > 0) {
+                errors.push(`method.schema.json zone "${zone.id}" cannot declare owners because its role is "${zone.role}".`);
+            }
+            for (const owner of zone.owned_by) {
+                if (!stageIds.has(owner)) {
+                    errors.push(`method.schema.json references unknown stage "${owner}" for zone "${zone.path}".`);
+                }
+            }
+        }
+        for (const stage of stages) {
+            for (const zoneId of stage.reads) {
+                if (!zoneById.has(zoneId)) {
+                    errors.push(`Stage "${stage.id}" reads unknown zone "${zoneId}".`);
+                }
+            }
+            for (const zoneId of stage.writes) {
+                const zone = zoneById.get(zoneId);
+                if (!zone) {
+                    errors.push(`Stage "${stage.id}" writes unknown zone "${zoneId}".`);
+                    continue;
+                }
+                if (zone.role === "input" || zone.role === "runtime") {
+                    errors.push(`Stage "${stage.id}" writes zone "${zoneId}" but zones with role "${zone.role}" are engine-owned inputs, not writable stage outputs.`);
+                }
+                if (!zone.owned_by.includes(stage.id)) {
+                    errors.push(`Stage "${stage.id}" writes zone "${zoneId}" but that zone is not owned by the stage in method.schema.json.`);
+                }
+            }
+            for (const artifactPath of Object.keys(stage.acceptance?.artifacts_must_not_contain ?? {})) {
+                const normalizedArtifactPath = artifactPath.replaceAll("\\", "/");
+                const artifactParts = normalizedArtifactPath.split("/").filter(Boolean);
+                if (artifactPath.startsWith("/") ||
+                    artifactPath.startsWith("\\") ||
+                    artifactParts.some((part) => part === "..")) {
+                    errors.push(`Stage "${stage.id}" artifacts_must_not_contain key "${artifactPath}" must be a portable-context relative artifact path.`);
+                    continue;
+                }
+                const matchingZone = zoneById.get(artifactPath);
+                if (matchingZone) {
+                    errors.push(`Stage "${stage.id}" artifacts_must_not_contain key "${artifactPath}" is a zone id. Use the zone path "${matchingZone.path}" instead.`);
+                }
+            }
+        }
+        for (const requiredZone of listBuiltinCompiledZoneSpecs().filter((zone) => zone.id === "raw" || zone.id === "runtime")) {
+            const match = zoneById.get(requiredZone.id);
+            if (!match) {
+                errors.push(`method.schema.json is missing required zone "${requiredZone.id}".`);
+                continue;
+            }
+            if (match.kind !== requiredZone.kind) {
+                errors.push(`method.schema.json zone "${requiredZone.id}" should be kind "${requiredZone.kind}".`);
+            }
+            if (match.role !== requiredZone.role) {
+                errors.push(`method.schema.json zone "${requiredZone.id}" should have role "${requiredZone.role}".`);
+            }
+        }
+    }
+    const stageDirs = existsSync(join(dirPath, "compile", "stages"))
+        ? listFilesRecursive(join(dirPath, "compile", "stages"), (filePath) => basename(filePath) === "SKILL.md")
+        : [];
+    const counts = {
+        starter_docs: collectStarterDocs(dirPath).length,
+        compile_stage_docs: stageDirs.length,
+        compiled_zones: methodSchema?.zones.length ?? 0,
+        method_zones: methodSchema?.zones.length ?? 0,
+    };
+    return {
+        ok: errors.length === 0,
+        summary: errors.length === 0 ? "Method package is valid." : `Method package has ${errors.length} issue(s).`,
+        errors,
+        counts,
+    };
+}
+function describeContextInterfaceValidationIssues(dirPath) {
+    const methodSchemaPath = contextInterfaceFilePath(dirPath);
+    if (!existsSync(methodSchemaPath)) {
+        return ["method.schema.json is missing."];
+    }
+    const raw = readJsonFileUnchecked(methodSchemaPath, "Method context interface");
+    if (raw === null) {
+        return ["method.schema.json is invalid JSON."];
+    }
+    const parsed = ContextInterfaceSchema.safeParse(raw);
+    if (parsed.success) {
+        return ["method.schema.json is missing or invalid."];
+    }
+    return parsed.error.issues.map((issue) => {
+        const path = issue.path.length > 0 ? issue.path.join(".") : "<root>";
+        return `method.schema.json ${path}: ${issue.message}`;
+    });
+}
+function basename(filePath) {
+    return filePath.split(/[\\/]/).pop() ?? filePath;
+}

package/dist/packages/method-package/method-definitions.d.ts

@@ -0,0 +1,83 @@
+import type { RuntimeStageAcceptance, MethodCompilerApi } from "../compiler/lib/schema.js";
+import type { MethodId, RuntimeContractType } from "../contracts/lib/schema.js";
+import { type ContextInterface, type ContextInterfaceZoneId, type MethodInputSpec } from "./context-interface.js";
+export interface MethodStarterDoc {
+    relativePath: string;
+    content: string;
+}
+export interface MethodStageDefinition {
+    id: string;
+    label: string;
+    description: string;
+    contractType: RuntimeContractType;
+    skillDir: string;
+    reads: ContextInterfaceZoneId[];
+    writes: ContextInterfaceZoneId[];
+    acceptance?: RuntimeStageAcceptance;
+}
+export interface MethodDefinition<TId extends string> {
+    id: TId;
+    compilerApi?: MethodCompilerApi;
+    purpose?: {
+        label: string;
+        taskHint: string;
+    };
+    inputs?: MethodInputSpec[];
+    label: string;
+    hint: string;
+    recommended?: boolean;
+    contextInterface?: ContextInterface;
+    schema?: ContextInterface;
+    stages: MethodStageDefinition[];
+    stagePolicyNotes?: Record<string, string[]>;
+    starterDocs?: MethodStarterDoc[];
+    scope?: "builtin" | "local";
+}
+export type CompiledMethodId = string;
+export declare function standaloneMethodDefinitionFromLocalPackage(local: {
+    id: string;
+    compiler_api?: MethodCompilerApi;
+    purpose?: {
+        label: string;
+        task_hint: string;
+    };
+    inputs?: MethodInputSpec[];
+    label: string;
+    hint: string;
+    stages?: Array<{
+        id: string;
+        label: string;
+        description?: string;
+        contract_type: RuntimeContractType;
+        skill_dir?: string;
+        reads: ContextInterfaceZoneId[];
+        writes: ContextInterfaceZoneId[];
+        acceptance?: RuntimeStageAcceptance;
+    }>;
+    stage_policy_notes?: Record<string, string[]>;
+    method_schema?: ContextInterface;
+    starter_docs: MethodStarterDoc[];
+}): MethodDefinition<string>;
+export declare function listCompiledMethodChoices(sourcePath?: string): MethodDefinition<string>[];
+export declare function getCompiledMethod(methodId: CompiledMethodId, options?: {
+    sourcePath?: string;
+}): MethodDefinition<string>;
+export declare function getActiveCompiledMethod(compiledPath: string): MethodDefinition<string>;
+export declare function resolveCompiledMethodId(value: unknown): CompiledMethodId | null;
+export declare function resolveCompiledMethodFromConfig(config: unknown): CompiledMethodId | null;
+export declare function resolveRequiredCompiledMethodFromConfig(config: unknown, label?: string): CompiledMethodId;
+export declare function formatCompiledMethodStageStep(methodId: CompiledMethodId, stage: string, options?: {
+    sourcePath?: string;
+}): string;
+export declare function getMethodStageDefinition(methodId: MethodId, stage: string, sourcePath?: string): MethodStageDefinition | null;
+export declare function getMethodStagePosition(methodId: MethodId, stage: string, sourcePath?: string): {
+    stageIndex: number;
+    stageTotal: number;
+    stages: string[];
+} | null;
+export declare function getMethodStages(methodId: MethodId, sourcePath?: string): string[];
+export declare function getActiveCompiledStages(compiledPath: string): string[];
+export declare function getMethodStagePolicyNotes(methodId: MethodId, stage: string, sourcePath?: string): string[];
+export declare function getActiveCompiledStagePolicyNotes(compiledPath: string, stage: string): string[];
+export declare function resolveActiveCompiledStageAcceptance(compiledPath: string, stage: string): MethodStageDefinition["acceptance"] | undefined;
+export declare function formatActiveCompiledMethodStageStep(compiledPath: string, stage: string): string;