@interf/compiler 0.5.1 → 0.6.3

package/dist/lib/local-workflows.js

@@ -1,399 +1 @@
-import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync, } from "node:fs";
-import { dirname, join, relative } from "node:path";
-import { z } from "zod";
-import { PACKAGE_ROOT } from "./config.js";
-import { isMarkdownFile } from "./util.js";
-import { listFilesRecursive } from "./filesystem.js";
-import { warnInterf } from "./logger.js";
-import { readJsonFileUnchecked, readJsonFileWithSchema } from "./parse.js";
-import { listBuiltinCompiledZoneSpecs, } from "./builtin-compiled-workflow.js";
-import { WorkflowCompilerApiSchema, RuntimeContractTypeSchema, RuntimeStageAcceptanceSchema, WorkflowStageZoneAccessSchema, WorkflowCompiledSchemaSchema, WorkflowIdPattern, } from "./schema.js";
-import { writeCompiledSchemaFile, compiledSchemaFilePath } from "./compiled-schema.js";
-const LocalWorkflowStageDefinitionSchema = z.object({
-    id: z.string().regex(WorkflowIdPattern),
-    label: z.string().min(1),
-    contract_type: RuntimeContractTypeSchema,
-    skill_dir: z.string().regex(WorkflowIdPattern).optional(),
-    description: z.string().min(1).optional(),
-    reads: WorkflowStageZoneAccessSchema,
-    writes: WorkflowStageZoneAccessSchema,
-    acceptance: RuntimeStageAcceptanceSchema.optional(),
-});
-const LocalWorkflowDefinitionSchema = z.object({
-    id: z.string().regex(WorkflowIdPattern),
-    type: z.literal("compiled"),
-    compiler_api: WorkflowCompilerApiSchema.optional(),
-    label: z.string().min(1),
-    hint: z.string().min(1),
-    extends: z.string().regex(WorkflowIdPattern).optional(),
-    stages: z.array(LocalWorkflowStageDefinitionSchema).min(1).optional(),
-    stage_policy_notes: z.record(z.string(), z.array(z.string())).optional(),
-});
-function workflowRootPath(sourcePath) {
-    return join(sourcePath, "interf", "workflows");
-}
-function builtinWorkflowRootPath(workflowId) {
-    return join(PACKAGE_ROOT, "builtin-workflows", workflowId);
-}
-export function workflowDefinitionPath(sourcePath, id) {
-    return join(workflowRootPath(sourcePath), id);
-}
-function collectStarterDocs(dirPath) {
-    return listFilesRecursive(dirPath, isMarkdownFile)
-        .filter((filePath) => relative(dirPath, filePath).replaceAll("\\", "/") !== "workflow.json")
-        .map((filePath) => ({
-        relativePath: relative(dirPath, filePath).replaceAll("\\", "/"),
-        content: readFileSync(filePath, "utf8"),
-    }))
-        .sort((a, b) => a.relativePath.localeCompare(b.relativePath));
-}
-export function loadWorkflowDefinitionFromDir(dirPath) {
-    const workflowPath = existsSync(join(dirPath, "workflow.json"))
-        ? join(dirPath, "workflow.json")
-        : null;
-    if (!workflowPath)
-        return null;
-    const definition = readJsonFileWithSchema(workflowPath, "local workflow definition", LocalWorkflowDefinitionSchema);
-    if (!definition)
-        return null;
-    const schemaPath = compiledSchemaFilePath(dirPath);
-    const compiledSchema = readJsonFileWithSchema(schemaPath, "compiled schema", WorkflowCompiledSchemaSchema);
-    if (!compiledSchema)
-        return null;
-    if (definition.type !== "compiled") {
-        warnInterf(`Warning: local workflow definition at ${workflowPath} has unexpected type "${definition.type}".`);
-        return null;
-    }
-    return {
-        ...definition,
-        compiled_schema: compiledSchema,
-        starter_docs: collectStarterDocs(dirPath),
-        directoryPath: dirPath,
-        workflowPath,
-        compiledSchemaPath: schemaPath,
-    };
-}
-export function listLocalWorkflowDefinitions(sourcePath) {
-    const root = workflowRootPath(sourcePath);
-    if (!existsSync(root))
-        return [];
-    return readdirSync(root)
-        .map((entry) => join(root, entry))
-        .filter((entryPath) => {
-        try {
-            return statSync(entryPath).isDirectory();
-        }
-        catch {
-            return false;
-        }
-    })
-        .map((entryPath) => loadWorkflowDefinitionFromDir(entryPath))
-        .filter((definition) => definition !== null)
-        .sort((a, b) => a.label.localeCompare(b.label));
-}
-export function loadLocalWorkflowDefinition(sourcePath, id) {
-    return loadWorkflowDefinitionFromDir(workflowDefinitionPath(sourcePath, id));
-}
-export function resolveWorkflowPackageSourcePath(sourcePath, workflowId) {
-    const builtinPath = builtinWorkflowRootPath(workflowId);
-    if (workflowId === "interf" && existsSync(join(builtinPath, "workflow.json")))
-        return builtinPath;
-    const localPath = workflowDefinitionPath(sourcePath, workflowId);
-    if (existsSync(join(localPath, "workflow.json")))
-        return localPath;
-    if (existsSync(join(builtinPath, "workflow.json")))
-        return builtinPath;
-    return null;
-}
-export function isWorkflowId(value) {
-    return WorkflowIdPattern.test(value);
-}
-function normalizeStagePolicyNotes(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        return undefined;
-    const normalized = {};
-    for (const [stageId, notes] of Object.entries(value)) {
-        if (!Array.isArray(notes))
-            continue;
-        const cleaned = Array.from(new Set(notes
-            .filter((note) => typeof note === "string")
-            .map((note) => note.trim())
-            .filter((note) => note.length > 0)));
-        if (cleaned.length > 0) {
-            normalized[stageId] = cleaned;
-        }
-    }
-    return Object.keys(normalized).length > 0 ? normalized : undefined;
-}
-function mergeStagePolicyNotes(currentValue, nextValue) {
-    const current = normalizeStagePolicyNotes(currentValue);
-    if (!nextValue || Object.keys(nextValue).length === 0)
-        return current;
-    const merged = { ...(current ?? {}) };
-    for (const [stageId, notes] of Object.entries(nextValue)) {
-        merged[stageId] = Array.from(new Set([
-            ...(merged[stageId] ?? []),
-            ...notes.map((note) => note.trim()).filter((note) => note.length > 0),
-        ]));
-    }
-    return Object.keys(merged).length > 0 ? merged : undefined;
-}
-function readWorkflowJsonObject(dirPath) {
-    const workflowPath = join(dirPath, "workflow.json");
-    const raw = readJsonFileUnchecked(workflowPath, "workflow package");
-    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
-        throw new Error(`Workflow package at ${dirPath} is missing a valid workflow.json.`);
-    }
-    return { ...raw };
-}
-export function patchWorkflowPackageMetadata(dirPath, options = {}) {
-    const workflowPath = join(dirPath, "workflow.json");
-    const schemaPath = compiledSchemaFilePath(dirPath);
-    const workflowJson = readWorkflowJsonObject(dirPath);
-    const normalizedStages = Array.isArray(workflowJson.stages) && workflowJson.stages.length > 0
-        ? workflowJson.stages
-        : null;
-    if (!normalizedStages) {
-        throw new Error(`Cannot patch workflow package at ${dirPath}: workflow.json must declare explicit stages before it can be copied or rewritten.`);
-    }
-    const nextWorkflowJson = {
-        ...workflowJson,
-        type: "compiled",
-        compiler_api: workflowJson.compiler_api ?? {
-            kind: "compiled",
-            version: 1,
-        },
-        stages: normalizedStages,
-        ...(options.id ? { id: options.id } : {}),
-        ...(options.label ? { label: options.label } : {}),
-        ...(options.hint ? { hint: options.hint } : {}),
-    };
-    delete nextWorkflowJson.extends;
-    const mergedStagePolicyNotes = mergeStagePolicyNotes(workflowJson.stage_policy_notes, options.stagePolicyNotes);
-    if (mergedStagePolicyNotes) {
-        nextWorkflowJson.stage_policy_notes = mergedStagePolicyNotes;
-    }
-    else {
-        delete nextWorkflowJson.stage_policy_notes;
-    }
-    writeFileSync(workflowPath, JSON.stringify(nextWorkflowJson, null, 2) + "\n");
-    const schemaLabel = `${String(nextWorkflowJson.label ?? workflowJson.label ?? options.id ?? "Workflow")} compiled schema`;
-    if (!existsSync(schemaPath)) {
-        writeCompiledSchemaFile(dirPath, normalizedStages, schemaLabel);
-        return;
-    }
-    const rawSchema = readJsonFileUnchecked(schemaPath, "compiled schema");
-    if (!rawSchema || typeof rawSchema !== "object" || Array.isArray(rawSchema))
-        return;
-    writeFileSync(schemaPath, JSON.stringify({
-        ...rawSchema,
-        label: schemaLabel,
-    }, null, 2) + "\n");
-}
-export function describeWorkflowPackagePortability(dirPath) {
-    const issues = [];
-    const workflowPath = join(dirPath, "workflow.json");
-    const schemaPath = compiledSchemaFilePath(dirPath);
-    if (!existsSync(workflowPath))
-        issues.push("missing workflow.json");
-    if (!existsSync(schemaPath))
-        issues.push("missing compiled.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 (issues.length > 0)
-        return issues;
-    let workflowJson;
-    try {
-        workflowJson = readWorkflowJsonObject(dirPath);
-    }
-    catch (error) {
-        issues.push(error instanceof Error ? error.message : String(error));
-        return issues;
-    }
-    const parsed = LocalWorkflowDefinitionSchema.safeParse(workflowJson);
-    if (!parsed.success) {
-        issues.push(...parsed.error.issues.map((issue) => issue.path.length > 0
-            ? `workflow.json ${issue.path.join(".")}: ${issue.message}`
-            : `workflow.json: ${issue.message}`));
-        return issues;
-    }
-    if (typeof parsed.data.extends === "string" && parsed.data.extends.trim().length > 0) {
-        issues.push("workflow.json uses legacy extends; portable workflow packages must be materialized standalone");
-    }
-    if (!parsed.data.stages || parsed.data.stages.length === 0) {
-        issues.push("workflow.json must declare explicit stages for a portable workflow package");
-        return issues;
-    }
-    for (const stage of parsed.data.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 isPortableWorkflowPackage(dirPath) {
-    return describeWorkflowPackagePortability(dirPath).length === 0;
-}
-export function copyWorkflowPackageDirectory(sourceWorkflowPath, targetWorkflowPath) {
-    const portabilityIssues = describeWorkflowPackagePortability(sourceWorkflowPath);
-    if (portabilityIssues.length > 0) {
-        throw new Error(`Workflow package at ${sourceWorkflowPath} is not directly copyable: ${portabilityIssues.join("; ")}.`);
-    }
-    rmSync(targetWorkflowPath, { recursive: true, force: true });
-    mkdirSync(dirname(targetWorkflowPath), { recursive: true });
-    cpSync(sourceWorkflowPath, targetWorkflowPath, { recursive: true });
-}
-export function validateWorkflowPackage(dirPath) {
-    const workflowPath = join(dirPath, "workflow.json");
-    const schemaPath = compiledSchemaFilePath(dirPath);
-    if (!existsSync(workflowPath)) {
-        return {
-            ok: false,
-            summary: `No workflow.json found at ${dirPath}`,
-            errors: ["Missing workflow.json"],
-            counts: {},
-        };
-    }
-    const raw = readJsonFileUnchecked(workflowPath, "workflow package");
-    if (!raw) {
-        return {
-            ok: false,
-            summary: `Failed to parse workflow.json at ${workflowPath}`,
-            errors: ["Invalid JSON in workflow.json"],
-            counts: {},
-        };
-    }
-    const parsed = LocalWorkflowDefinitionSchema.safeParse(raw);
-    if (!parsed.success) {
-        const issues = parsed.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`);
-        return {
-            ok: false,
-            summary: `workflow.json failed validation: ${issues.length} issue(s)`,
-            errors: issues,
-            counts: {},
-        };
-    }
-    const def = parsed.data;
-    const errors = [];
-    if (typeof def.extends === "string" && def.extends.trim().length > 0) {
-        errors.push("workflow.json uses legacy extends. Portable workflow packages must be materialized as standalone packages.");
-    }
-    if (!def.stages || def.stages.length === 0) {
-        errors.push("workflow.json must declare explicit stages. Legacy inherited packages are not portable.");
-    }
-    if (!existsSync(schemaPath)) {
-        errors.push("Missing compiled.schema.json.");
-    }
-    if (!existsSync(join(dirPath, "README.md"))) {
-        errors.push("Missing README.md.");
-    }
-    if (!existsSync(join(dirPath, "improve", "SKILL.md"))) {
-        errors.push("Missing improve/SKILL.md.");
-    }
-    if (!existsSync(join(dirPath, "use", "query", "SKILL.md"))) {
-        errors.push("Missing use/query/SKILL.md.");
-    }
-    const compiledSchema = readJsonFileWithSchema(schemaPath, "compiled schema", WorkflowCompiledSchemaSchema);
-    if (!compiledSchema) {
-        errors.push("compiled.schema.json is missing or invalid.");
-    }
-    if (def.stages && def.stages.length > 0) {
-        for (const stage of def.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"))) {
-                errors.push(`Missing compile/stages/${skillDir}/SKILL.md.`);
-            }
-        }
-    }
-    if (compiledSchema) {
-        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(compiledSchema.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 compiledSchema.zones) {
-            if (seenZoneIds.has(zone.id)) {
-                errors.push(`compiled.schema.json repeats zone id "${zone.id}".`);
-            }
-            seenZoneIds.add(zone.id);
-            const existingPathOwner = seenPaths.get(zone.path);
-            if (existingPathOwner) {
-                errors.push(`compiled.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(`compiled.schema.json zones "${zone.id}" and "${existingZoneId}" overlap on path "${zone.path}" / "${existingPath}".`);
-                }
-            }
-            seenPaths.set(zone.path, zone.id);
-            for (const owner of zone.owned_by) {
-                if (!stageIds.has(owner)) {
-                    errors.push(`compiled.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.owned_by.includes(stage.id)) {
-                    errors.push(`Stage "${stage.id}" writes zone "${zoneId}" but that zone is not owned by the stage in compiled.schema.json.`);
-                }
-            }
-        }
-        for (const requiredZone of listBuiltinCompiledZoneSpecs().filter((zone) => zone.id === "raw" || zone.id === "runtime")) {
-            const match = zoneById.get(requiredZone.id);
-            if (!match) {
-                errors.push(`compiled.schema.json is missing required zone "${requiredZone.id}".`);
-                continue;
-            }
-            if (match.kind !== requiredZone.kind) {
-                errors.push(`compiled.schema.json zone "${requiredZone.id}" should be kind "${requiredZone.kind}".`);
-            }
-        }
-    }
-    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: compiledSchema?.zones.length ?? 0,
-    };
-    return {
-        ok: errors.length === 0,
-        summary: errors.length === 0 ? "Workflow package is valid." : `Workflow package has ${errors.length} issue(s).`,
-        errors,
-        counts,
-    };
-}
-function basename(filePath) {
-    return filePath.split(/[\\/]/).pop() ?? filePath;
-}
+export * from "../packages/workflow-package/local-workflows.js";

package/dist/lib/package-root.d.ts

@@ -0,0 +1 @@
+export * from "../packages/workflow-package/lib/package-root.js";

package/dist/lib/package-root.js

@@ -0,0 +1 @@
+export * from "../packages/workflow-package/lib/package-root.js";

package/dist/lib/project-paths.d.ts

@@ -1,11 +1 @@
-export declare const PROJECT_INTERF_DIR = "interf";
-export declare const PROJECT_TESTS_DIR = "tests";
-export declare function projectInterfRoot(projectPath: string): string;
-export declare function compiledCompiledPathForDataset(projectPath: string, datasetName: string): string;
-export declare function datasetTestsRoot(projectPath: string, datasetName: string): string;
-export type DatasetTestTargetLabel = "file-as-is" | "compiled";
-export declare function datasetTestRunsRoot(projectPath: string, datasetName: string, target: DatasetTestTargetLabel): string;
-export declare function datasetLatestTestStatePath(projectPath: string, datasetName: string): string;
-export declare function datasetLatestTestSummaryPath(projectPath: string, datasetName: string): string;
-export declare function normalizeDatasetTestRunId(input: string): string;
-export declare function datasetTestRunPath(projectPath: string, datasetName: string, target: DatasetTestTargetLabel, generatedAt: string, runId: string, runSuffix?: string | null): string;
+export * from "../packages/project-model/project-paths.js";

package/dist/lib/project-paths.js

@@ -1,32 +1,3 @@
-import { join } from "node:path";
-export const PROJECT_INTERF_DIR = "interf";
-export const PROJECT_TESTS_DIR = "tests";
-export function projectInterfRoot(projectPath) {
-    return join(projectPath, PROJECT_INTERF_DIR);
-}
-export function compiledCompiledPathForDataset(projectPath, datasetName) {
-    return join(projectInterfRoot(projectPath), datasetName);
-}
-export function datasetTestsRoot(projectPath, datasetName) {
-    return join(projectInterfRoot(projectPath), PROJECT_TESTS_DIR, datasetName);
-}
-export function datasetTestRunsRoot(projectPath, datasetName, target) {
-    return join(datasetTestsRoot(projectPath, datasetName), target, "runs");
-}
-export function datasetLatestTestStatePath(projectPath, datasetName) {
-    return join(datasetTestsRoot(projectPath, datasetName), "latest.json");
-}
-export function datasetLatestTestSummaryPath(projectPath, datasetName) {
-    return join(datasetTestsRoot(projectPath, datasetName), "latest.md");
-}
-export function normalizeDatasetTestRunId(input) {
-    return input
-        .toLowerCase()
-        .trim()
-        .replace(/[^a-z0-9]+/g, "-")
-        .replace(/^-+|-+$/g, "")
-        .slice(0, 80);
-}
-export function datasetTestRunPath(projectPath, datasetName, target, generatedAt, runId, runSuffix) {
-    return join(datasetTestRunsRoot(projectPath, datasetName, target), `${generatedAt.replace(/[:.]/g, "-")}-${runId}${runSuffix ? `-${normalizeDatasetTestRunId(runSuffix)}` : ""}.json`);
-}
+// Compatibility shim for historical `src/lib/project-paths.ts` imports.
+// Source of truth: `src/packages/project-model/project-paths.ts`.
+export * from "../packages/project-model/project-paths.js";

package/dist/lib/runtime-acceptance.d.ts

@@ -1,9 +1 @@
-import { type CompiledState, type RuntimeStageAcceptance, type RuntimeStageContract } from "./schema.js";
-import { type RuntimeStageAcceptanceValidation } from "./runtime-types.js";
-export declare function stageRecordFromState(state: CompiledState | null, stageId: string): Record<string, unknown> | null;
-export declare function validateResolvedStageAcceptance(dirPath: string, options: {
-    stageId: string;
-    acceptance?: RuntimeStageAcceptance;
-    counts?: Record<string, number>;
-}): RuntimeStageAcceptanceValidation;
-export declare function validateStageContractAcceptance(dirPath: string, contract?: RuntimeStageContract | null): RuntimeStageAcceptanceValidation;
+export * from "../packages/compiler/runtime-acceptance.js";