@interf/compiler 0.9.1 → 0.9.3

package/dist/packages/workflow-package/workflow-definitions.js

@@ -1,211 +0,0 @@
-import { existsSync } from "node:fs";
-import { join } from "node:path";
-import { isWorkflowId, listLocalWorkflowDefinitions, loadLocalWorkflowDefinition, loadWorkflowDefinitionFromDir, } from "./local-workflows.js";
-import { warnInterf } from "../shared/logger.js";
-import { workflowPackagePathForCompiled } from "../compiler/compiled-paths.js";
-import { legacyWorkflowPackagePathForCompiled } from "../compiler/compiled-paths.js";
-import { resolveSourceControlPath } from "../project-model/interf.js";
-import { PACKAGE_ROOT } from "./lib/package-root.js";
-import { deriveWorkflowInputsFromContextInterface, } from "./context-interface.js";
-import { mergeStagePolicyNotesForStages } from "./workflow-stage-policy.js";
-let builtinInterfWorkflowCache = null;
-function toWorkflowStages(stages) {
-    return stages.map((stage) => ({
-        id: stage.id,
-        label: stage.label,
-        description: stage.description ?? stage.label,
-        contractType: stage.contract_type,
-        skillDir: stage.skill_dir ?? stage.id,
-        reads: [...stage.reads],
-        writes: [...stage.writes],
-        ...(stage.acceptance ? { acceptance: stage.acceptance } : {}),
-    }));
-}
-export function standaloneWorkflowDefinitionFromLocalPackage(local) {
-    if (!local.stages || local.stages.length === 0) {
-        throw new Error(`Workflow package "${local.id}" is missing explicit stages. Compiled-local and portable workflow packages must be standalone.`);
-    }
-    const stages = toWorkflowStages(local.stages);
-    const contextInterface = local.workflow_schema;
-    const inputs = local.inputs?.length
-        ? [...local.inputs]
-        : deriveWorkflowInputsFromContextInterface(contextInterface);
-    return {
-        id: local.id,
-        compilerApi: local.compiler_api ?? {
-            kind: "compiled",
-            version: 1,
-        },
-        ...(local.purpose
-            ? {
-                purpose: {
-                    label: local.purpose.label,
-                    taskHint: local.purpose.task_hint,
-                },
-            }
-            : {}),
-        inputs,
-        label: local.label,
-        hint: local.hint,
-        recommended: false,
-        contextInterface,
-        ...(contextInterface ? { schema: contextInterface } : {}),
-        stages,
-        stagePolicyNotes: mergeStagePolicyNotesForStages(stages, undefined, local.stage_policy_notes),
-        starterDocs: [...local.starter_docs],
-        scope: "local",
-    };
-}
-function builtinWorkflowPackagePath(workflowId) {
-    return join(PACKAGE_ROOT, "builtin-workflows", workflowId);
-}
-function getBuiltinInterfWorkflow() {
-    if (builtinInterfWorkflowCache)
-        return builtinInterfWorkflowCache;
-    const local = loadWorkflowDefinitionFromDir(builtinWorkflowPackagePath("interf"));
-    if (!local) {
-        throw new Error("Missing built-in Interf workflow package at builtin-workflows/interf.");
-    }
-    const resolved = standaloneWorkflowDefinitionFromLocalPackage(local);
-    builtinInterfWorkflowCache = {
-        ...resolved,
-        id: "interf",
-        recommended: true,
-        scope: "builtin",
-    };
-    return builtinInterfWorkflowCache;
-}
-function listBuiltinCompiledWorkflows() {
-    return [getBuiltinInterfWorkflow()];
-}
-function resolveCompiledWorkflowFromLocal(workflowId, sourcePath) {
-    const local = loadLocalWorkflowDefinition(sourcePath, workflowId);
-    if (!local)
-        return null;
-    if (local.extends) {
-        throw new Error(`Workflow "${workflowId}" uses legacy extends. Rewrite it as a standalone package before creating or compiling a compiled context.`);
-    }
-    const resolved = standaloneWorkflowDefinitionFromLocalPackage(local);
-    return resolved;
-}
-export function listCompiledWorkflowChoices(sourcePath) {
-    const builtins = listBuiltinCompiledWorkflows();
-    if (!sourcePath)
-        return builtins;
-    const locals = listLocalWorkflowDefinitions(sourcePath)
-        .filter((definition) => definition.id !== "interf")
-        .map((definition) => {
-        try {
-            return resolveCompiledWorkflowFromLocal(definition.id, sourcePath);
-        }
-        catch (error) {
-            warnInterf(`Warning: skipping local workflow "${definition.id}" because it could not be resolved cleanly: ${error instanceof Error ? error.message : String(error)}`);
-            return null;
-        }
-    })
-        .filter((definition) => definition !== null);
-    return [...builtins, ...locals];
-}
-export function getCompiledWorkflow(workflowId, options = {}) {
-    const builtin = listBuiltinCompiledWorkflows().find((candidate) => candidate.id === workflowId);
-    if (builtin)
-        return builtin;
-    if (options.sourcePath) {
-        const local = resolveCompiledWorkflowFromLocal(workflowId, options.sourcePath);
-        if (local)
-            return local;
-        throw new Error(`No local Method package found for "${workflowId}" under ${join(options.sourcePath, "interf", "methods", workflowId)}.`);
-    }
-    throw new Error(`Workflow "${workflowId}" is not built-in. Provide a source path so Interf can resolve a local workflow package.`);
-}
-export function getActiveCompiledWorkflow(compiledPath) {
-    const workflowPath = existsSync(join(workflowPackagePathForCompiled(compiledPath), "workflow.json"))
-        ? workflowPackagePathForCompiled(compiledPath)
-        : legacyWorkflowPackagePathForCompiled(compiledPath);
-    if (existsSync(join(workflowPath, "workflow.json"))) {
-        const local = loadWorkflowDefinitionFromDir(workflowPath);
-        if (!local) {
-            throw new Error(`Local Method package at ${workflowPath} is missing or invalid. Interf compile runs the local package directly; recreate or reseed this portable context.`);
-        }
-        if (local.extends) {
-            throw new Error(`Local Method package at ${workflowPath} still uses legacy extends. Materialize it as a standalone package before compiling this portable context.`);
-        }
-        return standaloneWorkflowDefinitionFromLocalPackage(local);
-    }
-    throw new Error(`Missing local Method package at ${workflowPath}. Interf compile runs the local package directly, so recreate or reseed this portable context under ${resolveSourceControlPath(compiledPath)}.`);
-}
-export function resolveCompiledWorkflowId(value) {
-    if (typeof value === "string" && isWorkflowId(value)) {
-        return value;
-    }
-    return null;
-}
-export function resolveCompiledWorkflowFromConfig(config) {
-    if (!config || typeof config !== "object")
-        return null;
-    const raw = config;
-    return resolveCompiledWorkflowId(raw.method) ?? resolveCompiledWorkflowId(raw.workflow);
-}
-export function resolveRequiredCompiledWorkflowFromConfig(config, label = "compiled config") {
-    const workflowId = resolveCompiledWorkflowFromConfig(config);
-    if (!workflowId) {
-        throw new Error(`Missing or invalid Method in ${label}.`);
-    }
-    return workflowId;
-}
-export function formatCompiledWorkflowStageStep(workflowId, stage, options = {}) {
-    return formatWorkflowStageStep(getCompiledWorkflow(workflowId, options), stage);
-}
-function resolveWorkflowDefinitionForStageMetadata(workflowId, sourcePath) {
-    if (sourcePath &&
-        existsSync(join(workflowPackagePathForCompiled(sourcePath), "workflow.json"))) {
-        return getActiveCompiledWorkflow(sourcePath);
-    }
-    return getCompiledWorkflow(workflowId, { sourcePath });
-}
-function formatWorkflowStageStep(workflow, stage) {
-    const stageIndex = workflow.stages.findIndex((candidate) => candidate.id === stage);
-    if (stageIndex === -1) {
-        throw new Error(`Stage "${stage}" is not part of the compiled runtime.`);
-    }
-    const stageDefinition = workflow.stages[stageIndex];
-    if (!stageDefinition) {
-        throw new Error(`Stage "${stage}" is not part of the compiled runtime.`);
-    }
-    return `Stage ${stageIndex + 1}/${workflow.stages.length} - ${stageDefinition.label}`;
-}
-export function getWorkflowStageDefinition(workflowId, stage, sourcePath) {
-    const workflow = resolveWorkflowDefinitionForStageMetadata(workflowId, sourcePath);
-    return workflow.stages.find((candidate) => candidate.id === stage) ?? null;
-}
-export function getWorkflowStagePosition(workflowId, stage, sourcePath) {
-    const stages = getWorkflowStages(workflowId, sourcePath);
-    const stageIndex = stages.findIndex((candidate) => candidate === stage);
-    if (stageIndex === -1)
-        return null;
-    return {
-        stageIndex: stageIndex + 1,
-        stageTotal: stages.length,
-        stages: [...stages],
-    };
-}
-export function getWorkflowStages(workflowId, sourcePath) {
-    return resolveWorkflowDefinitionForStageMetadata(workflowId, sourcePath).stages.map((definition) => definition.id);
-}
-export function getActiveCompiledStages(compiledPath) {
-    return getActiveCompiledWorkflow(compiledPath).stages.map((definition) => definition.id);
-}
-export function getWorkflowStagePolicyNotes(workflowId, stage, sourcePath) {
-    const workflow = resolveWorkflowDefinitionForStageMetadata(workflowId, sourcePath);
-    return [...(workflow.stagePolicyNotes?.[stage] ?? [])];
-}
-export function getActiveCompiledStagePolicyNotes(compiledPath, stage) {
-    const workflow = getActiveCompiledWorkflow(compiledPath);
-    return [...(workflow.stagePolicyNotes?.[stage] ?? [])];
-}
-export function resolveActiveCompiledStageAcceptance(compiledPath, stage) {
-    return getActiveCompiledWorkflow(compiledPath).stages.find((candidate) => candidate.id === stage)?.acceptance;
-}
-export function formatActiveCompiledWorkflowStageStep(compiledPath, stage) {
-    return formatWorkflowStageStep(getActiveCompiledWorkflow(compiledPath), stage);
-}

package/dist/packages/workflow-package/workflow-review-paths.d.ts

@@ -1,10 +0,0 @@
-import type { WorkflowImprovementContext } from "../compiler/lib/schema.js";
-export interface WorkflowImprovementReviewSourcePaths {
-    compiledRuntime: string | null;
-    testComparisons: string | null;
-    executionShells: string | null;
-    targetTestRuns: string | null;
-    targetTestSandboxes: string | null;
-}
-export declare function resolveWorkflowImprovementReviewSourcePaths(compiledPath: string): WorkflowImprovementReviewSourcePaths;
-export declare function resolveWorkflowImprovementReviewPaths(compiledPath: string): WorkflowImprovementContext["review_paths"];