@interf/compiler 0.6.1 → 0.6.4

package/dist/packages/compiler/compiled-stage-plan.js

@@ -0,0 +1,79 @@
+import { join } from "node:path";
+import { buildRuntimeStageContract, } from "./runtime.js";
+import { discoverSourceFiles } from "./discovery.js";
+import { listFilesRecursive } from "../shared/filesystem.js";
+import { compiledContractArtifactPathsForZoneIds, findCompiledSchemaZone, readCompiledSchemaFile, } from "./compiled-schema.js";
+import { buildLocalSkillContractExtension, buildStageInstructions, workflowCompileStageDirectory, } from "../workflow-package/workflow-helpers.js";
+import { getActiveCompiledStagePolicyNotes, resolveActiveCompiledStageAcceptance, } from "../workflow-package/workflow-definitions.js";
+import { workflowPackagePathForCompiled } from "./compiled-paths.js";
+import { readInterfConfig } from "../project-model/interf-detect.js";
+import { resolveCompiledContext, } from "./compiled-target.js";
+function zoneArtifactCount(compiledPath, zonePath, kind) {
+    const absolutePath = join(compiledPath, zonePath);
+    try {
+        if (kind === "file") {
+            return listFilesRecursive(absolutePath).length > 0 ? 1 : 0;
+        }
+    }
+    catch {
+        if (kind === "file")
+            return 0;
+    }
+    return listFilesRecursive(absolutePath).length;
+}
+export function resolveStageContractArtifacts(compiledPath, stageDefinition) {
+    const schema = readCompiledSchemaFile(workflowPackagePathForCompiled(compiledPath));
+    if (!schema) {
+        throw new Error(`Missing workflow schema for stage "${stageDefinition.id}" at ${workflowPackagePathForCompiled(compiledPath)}.`);
+    }
+    return {
+        reads: compiledContractArtifactPathsForZoneIds(schema, stageDefinition.reads),
+        writes: compiledContractArtifactPathsForZoneIds(schema, stageDefinition.writes),
+    };
+}
+export function buildStageCounts(compiledPath, stageDefinition) {
+    const context = resolveCompiledContext(compiledPath);
+    const sourceTotal = discoverSourceFiles(context.sourcePath, compiledPath).totalCount;
+    const schema = readCompiledSchemaFile(workflowPackagePathForCompiled(compiledPath));
+    const zoneCounts = {};
+    if (schema) {
+        for (const zoneId of new Set([...stageDefinition.reads, ...stageDefinition.writes])) {
+            const zone = findCompiledSchemaZone(schema, zoneId);
+            if (!zone)
+                continue;
+            zoneCounts[zoneId] = zoneArtifactCount(compiledPath, zone.path, zone.kind);
+        }
+    }
+    return {
+        source_total: sourceTotal,
+        read_zone_total: stageDefinition.reads.length,
+        write_zone_total: stageDefinition.writes.length,
+        ...zoneCounts,
+    };
+}
+export function buildStageContract(compiledPath, workflowId, stageDefinition, instructions) {
+    const config = readInterfConfig(compiledPath);
+    const stageArtifacts = resolveStageContractArtifacts(compiledPath, stageDefinition);
+    return buildRuntimeStageContract({
+        compiledName: config?.name ?? "compiled",
+        stageId: stageDefinition.id,
+        stageLabel: stageDefinition.label,
+        counts: buildStageCounts(compiledPath, stageDefinition),
+        stageReadArtifacts: stageArtifacts.reads,
+        stageWriteArtifacts: stageArtifacts.writes,
+        workflowNotes: getActiveCompiledStagePolicyNotes(compiledPath, workflowId, stageDefinition.id),
+        localSkillDocs: instructions.local_docs,
+        instructions,
+        acceptance: resolveActiveCompiledStageAcceptance(compiledPath, workflowId, stageDefinition.id),
+    });
+}
+export function buildCompiledStageExecutionPlan(compiledPath, stageDefinition) {
+    const context = resolveCompiledContext(compiledPath);
+    const localSkills = buildLocalSkillContractExtension(compiledPath, [workflowCompileStageDirectory(stageDefinition.skillDir)], "Use them to refine this workflow stage while still honoring the declared reads, writes, and proof rules.");
+    const instructions = buildStageInstructions(stageDefinition.skillDir, localSkills);
+    return {
+        context,
+        instructions,
+        contract: buildStageContract(compiledPath, context.workflowId, stageDefinition, instructions),
+    };
+}

package/dist/packages/compiler/compiled-stage-runner.d.ts

@@ -0,0 +1,10 @@
+import { type WorkflowExecutor } from "../agents/lib/executors.js";
+import { type WorkflowReporter, type WorkflowStageResult } from "../workflow-package/workflow-helpers.js";
+import { type CompiledStageExecutionDefinition } from "./compiled-target.js";
+export declare function runCompiledStage(options: {
+    executor: WorkflowExecutor;
+    compiledPath: string;
+    reporter?: WorkflowReporter;
+    reportStep?: boolean;
+    stageDefinition: CompiledStageExecutionDefinition;
+}): Promise<WorkflowStageResult>;

package/dist/packages/compiler/compiled-stage-runner.js

@@ -0,0 +1,46 @@
+import { createStageExecutionShell, freezeStageExecutionShell, syncStageExecutionShellWrites, } from "../agents/lib/shells.js";
+import { reconcileCompiledStageRun } from "./runtime-reconcile.js";
+import { refreshCompiledArtifacts } from "./state.js";
+import { validateCompiledStage } from "./validate.js";
+import { executeValidatedStage, } from "../workflow-package/workflow-stage-runner.js";
+import { formatActiveCompiledWorkflowStageStep, } from "../workflow-package/workflow-definitions.js";
+import { reportBlankLine, reportLine, } from "../workflow-package/workflow-helpers.js";
+import { buildCompiledStageExecutionPlan, } from "./compiled-stage-plan.js";
+export async function runCompiledStage(options) {
+    const stageDefinition = options.stageDefinition;
+    const plan = buildCompiledStageExecutionPlan(options.compiledPath, stageDefinition);
+    if (options.reportStep !== false) {
+        reportBlankLine(options.reporter);
+        reportLine(options.reporter, `${formatActiveCompiledWorkflowStageStep(options.compiledPath, plan.context.workflowId, stageDefinition.id)} (${stageDefinition.description.toLowerCase()})`);
+    }
+    const shell = createStageExecutionShell(options.compiledPath, plan.context.compiledName, plan.context.workflowId, stageDefinition, plan.contract.artifacts.writes);
+    try {
+        return await executeValidatedStage({
+            executor: options.executor,
+            compiledPath: options.compiledPath,
+            executionPath: shell.rootPath,
+            targetName: plan.context.compiledName,
+            workflow: plan.context.workflowId,
+            workflowSourcePath: options.compiledPath,
+            stageDefinition,
+            instructions: plan.instructions,
+            summary: `Executing ${stageDefinition.label.toLowerCase()}.`,
+            contract: plan.contract,
+            statusLines: [
+                `Emit exactly one startup line: STATUS: loaded ${stageDefinition.label.toLowerCase()} stage.`,
+                "Emit STATUS: reading declared inputs after you confirm the shell contract and local docs.",
+                "Emit STATUS: writing declared outputs after the stage starts updating the compiled zones.",
+                `Emit DONE: ${stageDefinition.id} complete when the declared outputs and proof are on disk.`,
+            ],
+            reporter: options.reporter,
+            completionCheck: () => validateCompiledStage(options.compiledPath, stageDefinition.id).ok,
+            syncWrites: () => syncStageExecutionShellWrites(options.compiledPath, shell.rootPath, stageDefinition, plan.contract.artifacts.writes),
+            reconcile: () => reconcileCompiledStageRun(options.compiledPath, stageDefinition),
+            refreshArtifacts: () => refreshCompiledArtifacts(options.compiledPath, { ensureViewSpec: true }),
+            validate: () => validateCompiledStage(options.compiledPath, stageDefinition.id),
+        });
+    }
+    finally {
+        freezeStageExecutionShell(shell.rootPath);
+    }
+}

package/dist/packages/compiler/compiled-target.d.ts

@@ -0,0 +1,11 @@
+import { type WorkflowStageDefinition } from "../workflow-package/workflow-definitions.js";
+import { type CompiledWorkflowId } from "../workflow-package/workflow-definitions.js";
+export interface CompiledStageExecutionDefinition extends WorkflowStageDefinition {
+}
+export declare function resolveCompiledContext(compiledPath: string): {
+    compiledName: string;
+    sourcePath: string;
+    controlPath: string;
+    workflowId: CompiledWorkflowId;
+};
+export declare function compiledExecutionStages(workflowId: CompiledWorkflowId, compiledPath: string): CompiledStageExecutionDefinition[];

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

@@ -0,0 +1,16 @@
+import { getActiveCompiledWorkflow, resolveRequiredCompiledWorkflowFromConfig, } from "../workflow-package/workflow-definitions.js";
+import { readInterfConfig, resolveSourceFolderPath, resolveSourceControlPath, } from "../project-model/interf-detect.js";
+export function resolveCompiledContext(compiledPath) {
+    const config = readInterfConfig(compiledPath);
+    const workflowId = resolveRequiredCompiledWorkflowFromConfig(config, `.interf/interf.json for ${compiledPath}`);
+    return {
+        compiledName: config?.name ?? "compiled",
+        sourcePath: resolveSourceFolderPath(compiledPath, config),
+        controlPath: resolveSourceControlPath(compiledPath),
+        workflowId,
+    };
+}
+export function compiledExecutionStages(workflowId, compiledPath) {
+    return getActiveCompiledWorkflow(compiledPath, workflowId)
+        .stages;
+}

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

@@ -0,0 +1,7 @@
+export interface DiscoveryResult {
+    sourceFiles: string[];
+    totalCount: number;
+    ignoredCount: number;
+}
+export declare function discoverSourceFiles(sourcePath: string, compiledPath: string): DiscoveryResult;
+export declare function loadIgnorePatterns(compiledPath: string): string[];

package/dist/packages/compiler/discovery.js

@@ -0,0 +1,80 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join, relative } from "node:path";
+import { listFilesRecursive } from "../shared/filesystem.js";
+const DEFAULT_IGNORE_DIRS = new Set([
+    "interf",
+    ".interf",
+    ".git",
+    ".obsidian",
+    ".claude",
+    "node_modules",
+]);
+const DEFAULT_IGNORE_FILES = new Set([
+    "interf.json",
+]);
+export function discoverSourceFiles(sourcePath, compiledPath) {
+    const userPatterns = loadIgnorePatterns(compiledPath);
+    let ignoredCount = 0;
+    const allFiles = listFilesRecursive(sourcePath, (filePath) => {
+        const rel = relative(sourcePath, filePath);
+        if (isIgnored(rel)) {
+            ignoredCount++;
+            return false;
+        }
+        if (userPatterns.length > 0 && matchesUserPattern(rel, userPatterns)) {
+            ignoredCount++;
+            return false;
+        }
+        return true;
+    });
+    const sourceFiles = allFiles
+        .map((f) => relative(sourcePath, f))
+        .sort((a, b) => a.localeCompare(b));
+    return {
+        sourceFiles,
+        totalCount: sourceFiles.length,
+        ignoredCount,
+    };
+}
+export function loadIgnorePatterns(compiledPath) {
+    const ignorePath = join(compiledPath, ".interfignore");
+    if (!existsSync(ignorePath))
+        return [];
+    return readFileSync(ignorePath, "utf-8")
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0 && !line.startsWith("#"));
+}
+function isIgnored(relativePath) {
+    if (DEFAULT_IGNORE_FILES.has(relativePath))
+        return true;
+    const segments = relativePath.split("/");
+    for (const segment of segments) {
+        if (segment.startsWith("."))
+            return true;
+        if (DEFAULT_IGNORE_DIRS.has(segment))
+            return true;
+    }
+    return false;
+}
+function matchesUserPattern(relativePath, patterns) {
+    for (const pattern of patterns) {
+        if (matchGlob(relativePath, pattern))
+            return true;
+    }
+    return false;
+}
+function matchGlob(path, pattern) {
+    if (pattern.endsWith("/")) {
+        const dir = pattern.slice(0, -1);
+        return path === dir || path.startsWith(dir + "/") || path.includes("/" + dir + "/");
+    }
+    if (pattern.startsWith("*.")) {
+        return path.endsWith(pattern.slice(1));
+    }
+    if (!pattern.includes("/") && !pattern.includes("*")) {
+        const filename = path.split("/").pop() ?? "";
+        return filename === pattern;
+    }
+    return path === pattern || path.startsWith(pattern + "/");
+}

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

@@ -0,0 +1,24 @@
+export * as primitives from "./workflow-primitives.js";
+export * as schema from "./lib/schema.js";
+export * as compiledSchema from "./compiled-schema.js";
+export * as compile from "./compiled-compile.js";
+export * as runtime from "./runtime.js";
+export * as runtimeAcceptance from "./runtime-acceptance.js";
+export * as runtimeContracts from "./runtime-contracts.js";
+export * as runtimeInventory from "./runtime-inventory.js";
+export * as runtimePaths from "./runtime-paths.js";
+export * as runtimePrompt from "./runtime-prompt.js";
+export * as runtimeReconcile from "./runtime-reconcile.js";
+export * as runtimeRuns from "./runtime-runs.js";
+export * as runtimeTypes from "./runtime-types.js";
+export * as state from "./state.js";
+export * as stateArtifacts from "./state-artifacts.js";
+export * as stateHealth from "./state-health.js";
+export * as stateIo from "./state-io.js";
+export * as statePaths from "./state-paths.js";
+export * as stateView from "./state-view.js";
+export * as validate from "./validate.js";
+export * as validateCompiled from "./validate-compiled.js";
+export * as validateHelpers from "./validate-helpers.js";
+export * as workflows from "./workflows.js";
+export type { CompiledCompileResult, CompiledSummarizeResult, StageShellRetentionMode, } from "./workflows.js";

package/dist/packages/compiler/index.js

@@ -0,0 +1,23 @@
+export * as primitives from "./workflow-primitives.js";
+export * as schema from "./lib/schema.js";
+export * as compiledSchema from "./compiled-schema.js";
+export * as compile from "./compiled-compile.js";
+export * as runtime from "./runtime.js";
+export * as runtimeAcceptance from "./runtime-acceptance.js";
+export * as runtimeContracts from "./runtime-contracts.js";
+export * as runtimeInventory from "./runtime-inventory.js";
+export * as runtimePaths from "./runtime-paths.js";
+export * as runtimePrompt from "./runtime-prompt.js";
+export * as runtimeReconcile from "./runtime-reconcile.js";
+export * as runtimeRuns from "./runtime-runs.js";
+export * as runtimeTypes from "./runtime-types.js";
+export * as state from "./state.js";
+export * as stateArtifacts from "./state-artifacts.js";
+export * as stateHealth from "./state-health.js";
+export * as stateIo from "./state-io.js";
+export * as statePaths from "./state-paths.js";
+export * as stateView from "./state-view.js";
+export * as validate from "./validate.js";
+export * as validateCompiled from "./validate-compiled.js";
+export * as validateHelpers from "./validate-helpers.js";
+export * as workflows from "./workflows.js";