@interf/compiler 0.6.1 → 0.6.3

package/dist/packages/compiler/validate-compiled.js

@@ -0,0 +1,241 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { discoverSourceFiles } from "../../lib/discovery.js";
+import { WORKFLOW_SCHEMA_FILE, compiledZoneAbsolutePath, findCompiledSchemaZone, readCompiledSchemaFile, workflowSchemaExists, } from "./compiled-schema.js";
+import { resolveSourceFolderPath } from "../project-model/interf-detect.js";
+import { compiledInterfConfigPath, workflowPackagePathForCompiled } from "../project-model/compiled-paths.js";
+import { readCompiledConfig } from "./validate.js";
+import { loadState } from "./state.js";
+import { validateResolvedStageAcceptance, stageRecordFromState } from "./runtime-acceptance.js";
+import { getActiveCompiledWorkflow, resolveRequiredCompiledWorkflowFromConfig, } from "../workflow-package/workflow-definitions.js";
+import { listFilesRecursive } from "../../lib/filesystem.js";
+function workflowSchemaPresent(dirPath) {
+    return workflowSchemaExists(join(dirPath, ".interf", "workflow"));
+}
+function countZoneArtifacts(compiledPath, zonePath, kind) {
+    const absolutePath = compiledZoneAbsolutePath(compiledPath, { path: zonePath });
+    if (!existsSync(absolutePath))
+        return 0;
+    if (kind === "file")
+        return 1;
+    return listFilesRecursive(absolutePath).length;
+}
+function readWorkflowContext(dirPath) {
+    const config = readCompiledConfig(dirPath);
+    const workflowId = config.valid
+        ? resolveRequiredCompiledWorkflowFromConfig(config.value, `.interf/interf.json for ${dirPath}`)
+        : null;
+    let workflow = null;
+    if (workflowId) {
+        try {
+            workflow = getActiveCompiledWorkflow(dirPath, workflowId);
+        }
+        catch {
+            workflow = null;
+        }
+    }
+    const schema = readCompiledSchemaFile(workflowPackagePathForCompiled(dirPath));
+    const state = loadState(dirPath);
+    const sourceTotal = config.valid
+        ? discoverSourceFiles(resolveSourceFolderPath(dirPath, config.value), dirPath).totalCount
+        : 0;
+    return {
+        config,
+        workflow,
+        schema,
+        state,
+        sourceTotal,
+        workflowId,
+    };
+}
+function stageRequired(sourceTotal, writeCounts, stageRecordPresent) {
+    return sourceTotal > 0 || writeCounts > 0 || stageRecordPresent;
+}
+function zoneWriteCount(compiledPath, schema, stage) {
+    const zoneCounts = {};
+    let total = 0;
+    for (const zoneId of stage.writes) {
+        const zone = findCompiledSchemaZone(schema, zoneId);
+        if (!zone)
+            continue;
+        const count = countZoneArtifacts(compiledPath, zone.path, zone.kind);
+        zoneCounts[zoneId] = count;
+        total += count;
+    }
+    return { total, zoneCounts };
+}
+function mergeValidationCounts(sourceTotal, stageRecord, zoneCounts) {
+    const merged = {
+        source_total: sourceTotal,
+        ...zoneCounts,
+    };
+    const stageCounts = stageRecord?.counts;
+    if (stageCounts && typeof stageCounts === "object" && !Array.isArray(stageCounts)) {
+        for (const [key, value] of Object.entries(stageCounts)) {
+            if (typeof value === "number" && Number.isFinite(value)) {
+                merged[key] = value;
+            }
+        }
+    }
+    return merged;
+}
+export function validateCompiled(dirPath) {
+    const context = readWorkflowContext(dirPath);
+    return {
+        config_present: context.config.present,
+        config_valid: context.config.valid,
+        config_type_match: context.config.typeMatch(),
+        workflow_present: existsSync(join(dirPath, ".interf", "workflow", "workflow.json")),
+        workflow_valid: context.workflow !== null,
+        schema_present: workflowSchemaPresent(dirPath),
+        schema_valid: context.schema !== null,
+    };
+}
+export function validateCompiledStage(dirPath, stageId) {
+    const context = readWorkflowContext(dirPath);
+    const checks = {
+        config_present: context.config.present,
+        config_valid: context.config.valid,
+        config_type_match: context.config.typeMatch(),
+        workflow_present: existsSync(join(dirPath, ".interf", "workflow", "workflow.json")),
+        workflow_valid: context.workflow !== null,
+        schema_present: workflowSchemaPresent(dirPath),
+        schema_valid: context.schema !== null,
+    };
+    const errors = [];
+    if (!checks.config_present)
+        errors.push(`Missing ${compiledInterfConfigPath(dirPath)}.`);
+    else if (!checks.config_valid)
+        errors.push(`Could not parse ${compiledInterfConfigPath(dirPath)}.`);
+    else if (!checks.config_type_match)
+        errors.push("Config is not a compiled context.");
+    if (!checks.workflow_present)
+        errors.push("Missing .interf/workflow/workflow.json.");
+    else if (!checks.workflow_valid)
+        errors.push("Could not load the active workflow package.");
+    if (!checks.schema_present)
+        errors.push(`Missing .interf/workflow/${WORKFLOW_SCHEMA_FILE}.`);
+    else if (!checks.schema_valid)
+        errors.push(`Could not parse .interf/workflow/${WORKFLOW_SCHEMA_FILE}.`);
+    const workflowStage = context.workflow?.stages.find((stage) => stage.id === stageId) ?? null;
+    checks.stage_present = workflowStage !== null;
+    if (!checks.stage_present) {
+        errors.push(`Workflow does not declare stage "${stageId}".`);
+    }
+    const stageRecord = stageRecordFromState(context.state, stageId);
+    checks.stage_record_present = stageRecord !== null;
+    checks.stage_finished = Boolean(stageRecord?.finished_at);
+    checks.stage_succeeded = stageRecord?.status === "succeeded";
+    const writeCounts = workflowStage && context.schema
+        ? zoneWriteCount(dirPath, context.schema, workflowStage)
+        : { total: 0, zoneCounts: {} };
+    const acceptanceCounts = mergeValidationCounts(context.sourceTotal, stageRecord, writeCounts.zoneCounts);
+    const required = stageRequired(context.sourceTotal, writeCounts.total, checks.stage_record_present);
+    let acceptanceErrors = [];
+    if (workflowStage && context.schema) {
+        const acceptanceValidation = validateResolvedStageAcceptance(dirPath, {
+            stageId,
+            acceptance: workflowStage.acceptance,
+            counts: acceptanceCounts,
+        });
+        checks.acceptance_ok = acceptanceValidation.ok;
+        acceptanceErrors = acceptanceValidation.failures;
+    }
+    else {
+        checks.acceptance_ok = false;
+    }
+    if (required && checks.stage_record_present && !checks.stage_finished) {
+        errors.push(`Stage "${stageId}" has no finished_at proof in runtime state.`);
+    }
+    if (required && checks.stage_record_present && !checks.stage_succeeded) {
+        errors.push(`Stage "${stageId}" is not marked succeeded in runtime state.`);
+    }
+    if (required) {
+        errors.push(...acceptanceErrors);
+    }
+    const ok = required ? errors.length === 0 : errors.length === 0;
+    const summary = !required
+        ? `Stage "${stageId}" is not required yet.`
+        : ok
+            ? `Stage "${stageId}" verified.`
+            : `Stage "${stageId}" failed — ${errors[0] ?? "acceptance not satisfied."}`;
+    return {
+        ok,
+        required,
+        stage: stageId,
+        summary,
+        counts: {
+            ...acceptanceCounts,
+            write_artifacts: writeCounts.total,
+            declared_write_zones: workflowStage?.writes.length ?? 0,
+        },
+        checks,
+        errors,
+    };
+}
+export function validateCompiledWorkflow(dirPath) {
+    const context = readWorkflowContext(dirPath);
+    const checks = {
+        config_present: context.config.present,
+        config_valid: context.config.valid,
+        config_type_match: context.config.typeMatch(),
+        workflow_present: existsSync(join(dirPath, ".interf", "workflow", "workflow.json")),
+        workflow_valid: context.workflow !== null,
+        schema_present: workflowSchemaPresent(dirPath),
+        schema_valid: context.schema !== null,
+    };
+    if (!context.workflow) {
+        const errors = ["Could not load the active workflow package."];
+        return {
+            ok: false,
+            required: true,
+            stage: "workflow",
+            summary: `Compiled workflow failed — ${errors[0]}`,
+            counts: { source_total: context.sourceTotal, stage_total: 0, completed_stages: 0 },
+            checks,
+            errors,
+            stage_results: {},
+        };
+    }
+    const stageResults = {};
+    const errors = [];
+    let completedStages = 0;
+    let failedStage = "compiled";
+    for (const stage of context.workflow.stages) {
+        const validation = validateCompiledStage(dirPath, stage.id);
+        stageResults[stage.id] = validation.ok;
+        if (validation.ok) {
+            completedStages += 1;
+            continue;
+        }
+        failedStage = stage.id;
+        errors.push(...validation.errors);
+        break;
+    }
+    const ok = errors.length === 0;
+    return {
+        ok,
+        required: context.sourceTotal > 0,
+        stage: failedStage,
+        summary: ok
+            ? `Compiled workflow verified — ${completedStages}/${context.workflow.stages.length} stages satisfied.`
+            : `Compiled workflow failed — ${errors[0] ?? "stage acceptance not satisfied."}`,
+        counts: {
+            source_total: context.sourceTotal,
+            stage_total: context.workflow.stages.length,
+            completed_stages: completedStages,
+        },
+        checks,
+        errors,
+        stage_results: stageResults,
+    };
+}
+export function validateCompiledSummarize(dirPath) {
+    return validateCompiledStage(dirPath, "summarize");
+}
+export function validateCompiledStructure(dirPath) {
+    return validateCompiledStage(dirPath, "structure");
+}
+export function validateCompiledCompile(dirPath) {
+    return validateCompiledWorkflow(dirPath);
+}

package/dist/packages/compiler/validate-helpers.d.ts

@@ -0,0 +1,12 @@
+export declare function asStringArray(value: unknown): string[];
+export declare function asRejectedEntries(value: unknown): Array<{
+    path: string;
+    reason: string;
+}>;
+export declare function asFileEntries(value: unknown): Array<{
+    file: string;
+}>;
+export declare function isSubset(left: Set<string>, right: Set<string>): boolean;
+export declare function setsEqual(left: Set<string>, right: Set<string>): boolean;
+export declare function setIntersectionSize(left: Set<string>, right: Set<string>): number;
+export declare function dedupeStrings(values: string[]): string[];

package/dist/packages/compiler/validate-helpers.js

@@ -0,0 +1,41 @@
+export function asStringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((item) => typeof item === "string");
+}
+export function asRejectedEntries(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((item) => !!item &&
+        typeof item === "object" &&
+        typeof item.path === "string" &&
+        typeof item.reason === "string");
+}
+export function asFileEntries(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((item) => !!item &&
+        typeof item === "object" &&
+        typeof item.file === "string");
+}
+export function isSubset(left, right) {
+    for (const item of left) {
+        if (!right.has(item))
+            return false;
+    }
+    return true;
+}
+export function setsEqual(left, right) {
+    return left.size === right.size && isSubset(left, right);
+}
+export function setIntersectionSize(left, right) {
+    let count = 0;
+    for (const item of left) {
+        if (right.has(item))
+            count += 1;
+    }
+    return count;
+}
+export function dedupeStrings(values) {
+    return Array.from(new Set(values));
+}

package/dist/packages/compiler/validate.d.ts

@@ -0,0 +1,21 @@
+import { readInterfConfig } from "../project-model/interf-detect.js";
+export declare function readCompiledConfig(dirPath: string): {
+    present: boolean;
+    valid: boolean;
+    value: ReturnType<typeof readInterfConfig>;
+    typeMatch(): boolean;
+};
+export declare function validateSynthFiles(files: string[], options?: {
+    requiredFrontmatterKeys?: string[];
+}): {
+    invalid_frontmatter: number;
+    short_abstracts: number;
+};
+export declare function countBrokenWikilinks(compiledRoot: string, noteIndexRoots: string[], linkScanRoots: string[]): number;
+export declare function asNumber(value: unknown): number;
+export declare function isOutputMarkdownFile(filePath: string): boolean;
+export declare function safeReadText(filePath: string): string | null;
+export declare function extractSynthAbstract(frontmatter: Record<string, unknown>, body: string): string | null;
+export declare function countSynthAbstractWords(frontmatter: Record<string, unknown>, body: string): number;
+export { validateCompiled, validateCompiledStage, validateCompiledWorkflow, validateCompiledSummarize, validateCompiledStructure, validateCompiledCompile, } from "./validate-compiled.js";
+export type { CompiledValidationSummary, CompiledStageValidation, CompiledWorkflowValidation, } from "./validate-compiled.js";

package/dist/packages/compiler/validate.js

@@ -0,0 +1,249 @@
+import { existsSync, readFileSync, statSync, } from "node:fs";
+import { basename, extname, join } from "node:path";
+import { readCompiledSchemaFile } from "./compiled-schema.js";
+import { compiledKnowledgeRootPath } from "./compiled-schema.js";
+import { workflowPackagePathForCompiled } from "../project-model/compiled-paths.js";
+import { listFilesRecursive } from "../../lib/filesystem.js";
+import { readInterfConfig } from "../project-model/interf-detect.js";
+import { parseJsonFrontmatter } from "../../lib/parse.js";
+import { compiledInterfConfigPath } from "../project-model/compiled-paths.js";
+const MIN_ABSTRACT_WORDS = 5;
+const WIKILINK_PATTERN = /!?\[\[([^[\]]+)\]\]/g;
+export function readCompiledConfig(dirPath) {
+    const configPath = compiledInterfConfigPath(dirPath);
+    const value = readInterfConfig(dirPath);
+    const present = existsSync(configPath);
+    if (!present) {
+        return {
+            present: false,
+            valid: false,
+            value: null,
+            typeMatch: () => false,
+        };
+    }
+    return {
+        present: true,
+        valid: value !== null,
+        value,
+        typeMatch() {
+            return value?.type === "compiled" && typeof value?.source?.path === "string";
+        },
+    };
+}
+export function validateSynthFiles(files, options) {
+    let invalidFrontmatter = 0;
+    let shortAbstracts = 0;
+    for (const filePath of files) {
+        const content = safeReadText(filePath);
+        if (content === null)
+            continue;
+        const parsed = parseJsonFrontmatter(content);
+        if (!parsed || !hasRequiredFrontmatterKeys(parsed.frontmatter, options?.requiredFrontmatterKeys)) {
+            invalidFrontmatter += 1;
+            continue;
+        }
+        const abstractWords = countSynthAbstractWords(parsed.frontmatter, parsed.body);
+        if (abstractWords < MIN_ABSTRACT_WORDS) {
+            shortAbstracts += 1;
+        }
+    }
+    return {
+        invalid_frontmatter: invalidFrontmatter,
+        short_abstracts: shortAbstracts,
+    };
+}
+export function countBrokenWikilinks(compiledRoot, noteIndexRoots, linkScanRoots) {
+    const zonePathById = compiledZoneDirectoryPaths(compiledRoot);
+    const knowledgeRelativePrefixes = compiledKnowledgeRelativePrefixes(zonePathById);
+    const noteIndex = new Set();
+    for (const filePath of dedupeFiles(noteIndexRoots)) {
+        for (const target of collectWikilinkTargets(filePath)) {
+            noteIndex.add(target.toLowerCase());
+        }
+    }
+    let brokenLinks = 0;
+    for (const filePath of dedupeFiles(linkScanRoots)) {
+        const content = safeReadText(filePath);
+        if (content === null)
+            continue;
+        const matches = content.matchAll(WIKILINK_PATTERN);
+        for (const match of matches) {
+            const rawTarget = match[1]?.trim();
+            if (!rawTarget)
+                continue;
+            const target = rawTarget.split("|")[0]?.split("#")[0]?.trim();
+            if (!target)
+                continue;
+            if (target.includes("/")) {
+                if (!wikilinkPathExists(compiledRoot, target, zonePathById, knowledgeRelativePrefixes)) {
+                    brokenLinks += 1;
+                }
+                continue;
+            }
+            if (!noteIndex.has(target.toLowerCase()) &&
+                !noteIndex.has(noteName(target).toLowerCase()) &&
+                !wikilinkPathExists(compiledRoot, target, zonePathById, knowledgeRelativePrefixes) &&
+                !wikilinkPathExists(compiledRoot, noteName(target), zonePathById, knowledgeRelativePrefixes)) {
+                brokenLinks += 1;
+            }
+        }
+    }
+    return brokenLinks;
+}
+export function asNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+export function isOutputMarkdownFile(filePath) {
+    return extname(filePath) === ".md" && basename(filePath) !== "AGENTS.md";
+}
+export function safeReadText(filePath) {
+    try {
+        return readFileSync(filePath, "utf-8");
+    }
+    catch {
+        return null;
+    }
+}
+function dedupeFiles(dirPaths) {
+    const seen = new Set();
+    const files = [];
+    for (const dirPath of dirPaths) {
+        if (existsSync(dirPath)) {
+            try {
+                const stat = statSync(dirPath);
+                if (stat.isFile()) {
+                    if (!seen.has(dirPath) && isOutputMarkdownFile(dirPath)) {
+                        seen.add(dirPath);
+                        files.push(dirPath);
+                    }
+                    continue;
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        for (const filePath of listFilesRecursive(dirPath, isOutputMarkdownFile)) {
+            if (seen.has(filePath))
+                continue;
+            seen.add(filePath);
+            files.push(filePath);
+        }
+    }
+    return files;
+}
+function hasRequiredFrontmatterKeys(frontmatter, requiredKeys) {
+    return (requiredKeys ?? []).every((field) => field in frontmatter);
+}
+function extractBodyAbstract(body) {
+    const lines = body.split(/\r?\n/);
+    const abstractHeadingIndex = lines.findIndex((line) => /^#{1,2}\s+Abstract\s*$/.test(line.trim()));
+    if (abstractHeadingIndex < 0)
+        return null;
+    const abstractLines = [];
+    for (let index = abstractHeadingIndex + 1; index < lines.length; index += 1) {
+        const line = lines[index] ?? "";
+        if (/^#{1,2}\s+\S/.test(line.trim()))
+            break;
+        abstractLines.push(line);
+    }
+    const abstractText = abstractLines.join("\n").trim();
+    return abstractText.length > 0 ? abstractText : null;
+}
+export function extractSynthAbstract(frontmatter, body) {
+    const frontmatterAbstract = typeof frontmatter.abstract === "string" ? frontmatter.abstract.trim() : "";
+    if (frontmatterAbstract.length > 0) {
+        return frontmatterAbstract;
+    }
+    return extractBodyAbstract(body);
+}
+export function countSynthAbstractWords(frontmatter, body) {
+    const abstract = extractSynthAbstract(frontmatter, body);
+    if (!abstract)
+        return 0;
+    return countWords(abstract);
+}
+function countWords(text) {
+    return text
+        .split(/\s+/)
+        .map((word) => word.trim())
+        .filter((word) => /[A-Za-z0-9]/.test(word)).length;
+}
+function noteName(filePath) {
+    return basename(filePath, extname(filePath));
+}
+function wikilinkPathExists(compiledRoot, target, zonePathById, knowledgeRelativePrefixes) {
+    return linkPathCandidates(compiledRoot, target, zonePathById, knowledgeRelativePrefixes)
+        .some((candidate) => existsSync(candidate));
+}
+function linkPathCandidates(compiledRoot, target, zonePathById, knowledgeRelativePrefixes) {
+    const candidates = new Set();
+    addPathCandidate(candidates, join(compiledRoot, target));
+    const [firstSegment] = target.split("/");
+    if (firstSegment && knowledgeRelativePrefixes.has(firstSegment)) {
+        addPathCandidate(candidates, join(compiledKnowledgeRootPath(compiledRoot), target));
+    }
+    if (firstSegment) {
+        const normalizedPrefix = zonePathById.get(firstSegment);
+        if (normalizedPrefix) {
+            const remainder = target.slice(firstSegment.length).replace(/^\/+/, "");
+            addPathCandidate(candidates, join(compiledRoot, normalizedPrefix, remainder));
+        }
+    }
+    return Array.from(candidates);
+}
+function addPathCandidate(candidates, absolutePath) {
+    candidates.add(absolutePath);
+    if (!absolutePath.endsWith(".md")) {
+        candidates.add(`${absolutePath}.md`);
+    }
+}
+function compiledZoneDirectoryPaths(compiledRoot) {
+    const workflowRoot = workflowPackagePathForCompiled(compiledRoot);
+    const schema = readCompiledSchemaFile(workflowRoot);
+    if (!schema)
+        return new Map();
+    return new Map(schema.zones
+        .filter((zone) => zone.kind === "directory")
+        .map((zone) => [zone.id, zone.path]));
+}
+function compiledKnowledgeRelativePrefixes(zonePathById) {
+    const prefixes = new Set();
+    for (const zonePath of zonePathById.values()) {
+        const [root, leaf, ...rest] = zonePath.split("/");
+        if (root !== "knowledge" || !leaf || rest.length > 0)
+            continue;
+        prefixes.add(leaf);
+    }
+    return prefixes;
+}
+function collectWikilinkTargets(filePath) {
+    const targets = new Set();
+    targets.add(noteName(filePath));
+    const content = safeReadText(filePath);
+    if (content === null)
+        return Array.from(targets);
+    const parsed = parseJsonFrontmatter(content);
+    const frontmatter = parsed?.frontmatter;
+    if (!frontmatter)
+        return Array.from(targets);
+    addFrontmatterLinkTarget(targets, frontmatter.label);
+    addFrontmatterLinkTarget(targets, frontmatter.title);
+    addFrontmatterLinkTarget(targets, frontmatter.alias);
+    addFrontmatterLinkTarget(targets, frontmatter.aliases);
+    return Array.from(targets);
+}
+function addFrontmatterLinkTarget(targets, value) {
+    if (typeof value === "string") {
+        const trimmed = value.trim();
+        if (trimmed.length > 0)
+            targets.add(trimmed);
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (const entry of value) {
+            addFrontmatterLinkTarget(targets, entry);
+        }
+    }
+}
+export { validateCompiled, validateCompiledStage, validateCompiledWorkflow, validateCompiledSummarize, validateCompiledStructure, validateCompiledCompile, } from "./validate-compiled.js";

package/dist/packages/compiler/workflow-primitives.d.ts

@@ -0,0 +1,2 @@
+export declare const COMPILED_ZONE_KINDS: readonly ["directory", "file", "runtime"];
+export type CompiledZoneKind = typeof COMPILED_ZONE_KINDS[number];

package/dist/packages/compiler/workflow-primitives.js

@@ -0,0 +1,5 @@
+export const COMPILED_ZONE_KINDS = [
+    "directory",
+    "file",
+    "runtime",
+];

package/dist/packages/compiler/workflows.d.ts

@@ -0,0 +1,15 @@
+import { type InterfConfig } from "../project-model/interf-detect.js";
+export type { WorkflowReporter, WorkflowStageResult, LocalSkillContractExtension } from "../workflow-package/workflow-helpers.js";
+export { workflowQueryDirectory, workflowImproveDirectory, workflowCompileStageDirectory, emptyLocalSkillContractExtension, buildLocalSkillContractExtension, buildLocalSkillContractExtensionRelativeTo, mergeLocalSkillContractExtensions, buildStageInstructions, reportLine, reportBlankLine, reportValidationFailure, resolveStageAcceptance, validateStageOutcome, } from "../workflow-package/workflow-helpers.js";
+export type CompiledCheck = "compiled" | "stage";
+export interface DetectedInterfTarget {
+    path: string;
+    kind: "compiled";
+    engineType: "compiled";
+    config: InterfConfig;
+}
+export declare function detectCompiled(cwd: string): DetectedInterfTarget | null;
+export declare function createCompiled(name: string, sourcePath: string, workflowId?: string, about?: string, datasetPath?: string): string;
+export declare function verifyCompiledCheck(check: CompiledCheck, compiledPath: string): import("./validate-compiled.js").CompiledWorkflowValidation;
+export { runCompiledSummarize, runCompiledCompile, compileCompiled, resolveCompiledContext, compiledExecutionStages, } from "./compiled-compile.js";
+export type { CompiledSummarizeResult, CompiledCompileResult, CompiledStageExecutionDefinition, StageShellRetentionMode, } from "./compiled-compile.js";

package/dist/packages/compiler/workflows.js

@@ -0,0 +1,31 @@
+import { createCompiled as createCompiledScaffold, } from "../project-model/interf-scaffold.js";
+import { detectInterf } from "../project-model/interf-detect.js";
+import { validateCompiledCompile, } from "./validate.js";
+export { workflowQueryDirectory, workflowImproveDirectory, workflowCompileStageDirectory, emptyLocalSkillContractExtension, buildLocalSkillContractExtension, buildLocalSkillContractExtensionRelativeTo, mergeLocalSkillContractExtensions, buildStageInstructions, reportLine, reportBlankLine, reportValidationFailure, resolveStageAcceptance, validateStageOutcome, } from "../workflow-package/workflow-helpers.js";
+export function detectCompiled(cwd) {
+    const detected = detectInterf(cwd);
+    if (!detected)
+        return null;
+    return {
+        path: detected.path,
+        kind: "compiled",
+        engineType: "compiled",
+        config: detected.config,
+    };
+}
+export function createCompiled(name, sourcePath, workflowId = "interf", about, datasetPath = sourcePath) {
+    return createCompiledScaffold(name, sourcePath, workflowId, about, datasetPath);
+}
+export function verifyCompiledCheck(check, compiledPath) {
+    switch (check) {
+        case "compiled":
+            return validateCompiledCompile(compiledPath);
+        case "stage":
+            return validateCompiledCompile(compiledPath);
+        default: {
+            const exhaustiveCheck = check;
+            throw new Error(`Unknown compiled check: ${exhaustiveCheck}`);
+        }
+    }
+}
+export { runCompiledSummarize, runCompiledCompile, compileCompiled, resolveCompiledContext, compiledExecutionStages, } from "./compiled-compile.js";

package/dist/packages/project-model/compiled-paths.d.ts

@@ -0,0 +1,40 @@
+export declare const COMPILED_INTERF_DIR = ".interf";
+export declare const COMPILED_CONFIG_FILE = "interf.json";
+export declare const COMPILED_WORKFLOW_DIR = "workflow";
+export declare const COMPILED_TEST_DIR = "tests";
+export declare const COMPILED_TEST_TARGETS_DIR = "targets";
+export declare const COMPILED_RUNTIME_DIR = "runtime";
+export declare const COMPILED_RUNTIME_STATE_FILE = "state.json";
+export declare const COMPILED_RUNTIME_HEALTH_FILE = "health.json";
+export declare const COMPILED_RUNTIME_VIEW_SPEC_FILE = "view-spec.json";
+export declare const COMPILED_RUNTIME_RAW_SNAPSHOT_FILE = "raw-snapshot.json";
+export declare const COMPILED_RUNTIME_INVENTORY_FILE = "inventory.json";
+export declare const COMPILED_RUNTIME_RUN_FILE = "run.json";
+export declare const COMPILED_RUNTIME_RUN_HISTORY_FILE = "run-history.jsonl";
+export declare const COMPILED_RUNTIME_STAGE_CONTRACT_FILE = "stage-contract.json";
+export declare function compiledRuntimeRoot(compiledPath: string): string;
+export declare function compiledRuntimeFilePath(compiledPath: string, fileName: string): string;
+export declare function compiledInterfRoot(compiledPath: string): string;
+export declare function compiledInterfConfigPath(compiledPath: string): string;
+export declare function workflowPackagePathForCompiled(compiledPath: string): string;
+export declare function testRootForCompiled(compiledPath: string): string;
+export declare function testTargetsRootForCompiled(compiledPath: string): string;
+export declare function stageExecutionShellsRoot(compiledPath: string): string;
+export declare function workflowImprovementLoopsRoot(compiledPath: string): string;
+export declare function workflowImprovementRunRoot(compiledPath: string, runId: string): string;
+export declare function workflowImprovementLoopRoot(compiledPath: string, runId: string, loopIndex: number): string;
+export declare function targetTestRunsRootForCompiled(compiledPath: string): string;
+export declare function targetTestSandboxesRootForCompiled(compiledPath: string): string;
+export declare function compiledRuntimeLogsRoot(compiledPath: string): string;
+export declare function compiledRuntimeArchivedStageContractPath(compiledPath: string, runId: string): string;
+export declare function compiledQueryAcceptanceRoot(compiledPath: string): string;
+export declare function compiledRuntimeStatePath(compiledPath: string): string;
+export declare function compiledRuntimeHealthPath(compiledPath: string): string;
+export declare function compiledRuntimeViewSpecPath(compiledPath: string): string;
+export declare function compiledRawSnapshotMetadataPath(compiledPath: string): string;
+export declare function compiledRuntimeInventoryPath(compiledPath: string): string;
+export declare function compiledRuntimeRunPath(compiledPath: string): string;
+export declare function compiledRuntimeRunHistoryPath(compiledPath: string): string;
+export declare function compiledRuntimeStageContractPath(compiledPath: string): string;
+export declare function resolveSourceControlPathForCompiled(compiledPath: string): string;
+export declare function defaultControlPathForCompiled(compiledPath: string): string;