@interf/compiler 0.3.4 → 0.4.0

package/builtin-workflows/interf/workspace.schema.json

@@ -0,0 +1,75 @@
+{
+  "kind": "workspace-schema",
+  "version": 1,
+  "target_type": "workspace",
+  "label": "Interf Compiler (Recommended) workspace schema",
+  "zones": [
+    {
+      "id": "raw",
+      "path": "raw",
+      "kind": "directory",
+      "required": true,
+      "owned_by": [],
+      "description": "Workspace-local raw snapshot copied from the dataset for direct evidence and verification."
+    },
+    {
+      "id": "summaries",
+      "path": "summaries",
+      "kind": "directory",
+      "required": true,
+      "owned_by": [
+        "summarize"
+      ],
+      "description": "Per-file evidence notes produced by file-evidence stages."
+    },
+    {
+      "id": "knowledge-entities",
+      "path": "knowledge/entities",
+      "kind": "directory",
+      "required": true,
+      "owned_by": [
+        "structure"
+      ],
+      "description": "Canonical entity notes produced by knowledge-structure stages."
+    },
+    {
+      "id": "knowledge-claims",
+      "path": "knowledge/claims",
+      "kind": "directory",
+      "required": true,
+      "owned_by": [
+        "structure"
+      ],
+      "description": "Claim notes produced by knowledge-structure stages."
+    },
+    {
+      "id": "knowledge-indexes",
+      "path": "knowledge/indexes",
+      "kind": "directory",
+      "required": true,
+      "owned_by": [
+        "structure",
+        "shape"
+      ],
+      "description": "Retrieval indexes and navigation notes produced by structure and shape stages."
+    },
+    {
+      "id": "home",
+      "path": "home.md",
+      "kind": "file",
+      "required": true,
+      "owned_by": [
+        "shape"
+      ],
+      "description": "Primary entrypoint note for agents using the compiled workspace."
+    },
+    {
+      "id": "runtime",
+      "path": ".interf/runtime",
+      "kind": "runtime",
+      "required": true,
+      "owned_by": [],
+      "description": "CLI-owned runtime state, health, stage contracts, and proof artifacts."
+    }
+  ]
+}

package/dist/bin.d.ts

@@ -1,3 +1,2 @@
 #!/usr/bin/env node
 export {};
-//# sourceMappingURL=bin.d.ts.map

package/dist/bin.js

@@ -27,4 +27,3 @@ yargs(hideBin(process.argv))
     .help()
     .version()
     .parse();
-//# sourceMappingURL=bin.js.map

package/dist/commands/compile-controller.d.ts

@@ -0,0 +1,14 @@
+import type { WorkflowExecutionProfile, WorkflowExecutor } from "../lib/executors.js";
+import type { SourceWorkspaceConfig } from "../lib/schema.js";
+import type { StageShellRetentionMode } from "../lib/workflows.js";
+export declare function runConfiguredWorkspaceCompile(options: {
+    executor: WorkflowExecutor;
+    testExecutor?: WorkflowExecutor | null;
+    workspacePath: string;
+    sourcePath: string;
+    workspaceConfig: SourceWorkspaceConfig | null;
+    executionProfile?: WorkflowExecutionProfile;
+    maxAttemptsOverride: number | null;
+    maxLoopsOverride: number | null;
+    preserveStageShells?: StageShellRetentionMode;
+}): Promise<boolean>;

package/dist/commands/compile-controller.js

@@ -0,0 +1,409 @@
+import { cpSync, existsSync, mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import chalk from "chalk";
+import { readInterfConfig } from "../lib/interf.js";
+import { resetWorkspaceGeneratedState } from "../lib/workspace-reset.js";
+import { formatActiveWorkspaceWorkflowStageStep, resolveWorkspaceWorkflowFromConfig, } from "../lib/workflow-definitions.js";
+import { resolveWorkspaceCompileMaxAttempts, resolveWorkspaceCompileMaxLoops, } from "../lib/source-config.js";
+import { runWorkflowImprovementLoop } from "../lib/workflow-improvement.js";
+import { stageExecutionShellsRoot, workflowPackagePathForWorkspace, } from "../lib/workspace-paths.js";
+import { compileWorkspaceWithReporter } from "./workspace-flow.js";
+import { printSavedTestOutcome, questionPassRate, runSavedWorkspaceTest, } from "./test-flow.js";
+function printCompileFailure(workspacePath, failedStage) {
+    const workflowId = resolveWorkspaceWorkflowFromConfig(readInterfConfig(workspacePath));
+    const failedStageLabel = formatActiveWorkspaceWorkflowStageStep(workspacePath, workflowId, failedStage ?? "compile");
+    console.log(chalk.red(`  ${failedStageLabel} failed.`));
+}
+function testScore(outcome) {
+    return (outcome.result.passedCases * 1000) + outcome.result.passedChecks;
+}
+const BEST_VARIATION_RESTORE_PATHS = [
+    "AGENTS.md",
+    "CLAUDE.md",
+    "home.md",
+    "summaries",
+    "knowledge",
+    ".claude",
+    ".codex",
+    ".agents",
+    ".cursor",
+    ".obsidian",
+    ".interf/interf.json",
+    ".interf/workflow",
+    ".interf/runtime/state.json",
+    ".interf/runtime/health.json",
+    ".interf/runtime/view-spec.json",
+    ".interf/runtime/inventory.json",
+    ".interf/runtime/run.json",
+    ".interf/runtime/raw-snapshot.json",
+    ".interf/runtime/stage-contract.json",
+    ".interf/runtime/summarize-targets.json",
+];
+function copyRelativePathIfPresent(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, {
+        recursive: true,
+        force: true,
+        errorOnExist: false,
+    });
+}
+function snapshotWorkspaceBestState(workspacePath) {
+    const snapshotRoot = mkdtempSync(join(tmpdir(), "interf-compile-attempt-"));
+    const snapshotPath = join(snapshotRoot, "workspace");
+    for (const relativePath of BEST_VARIATION_RESTORE_PATHS) {
+        copyRelativePathIfPresent(workspacePath, snapshotPath, relativePath);
+    }
+    return snapshotPath;
+}
+function restoreWorkspaceBestState(snapshotPath, workspacePath) {
+    for (const relativePath of BEST_VARIATION_RESTORE_PATHS) {
+        rmSync(join(workspacePath, relativePath), { recursive: true, force: true });
+        copyRelativePathIfPresent(snapshotPath, workspacePath, relativePath);
+    }
+}
+async function runWorkflowVariation(options) {
+    let bestOutcome = null;
+    let bestSnapshotPath = null;
+    let bestAttempt = 0;
+    let attemptsRun = 0;
+    try {
+        for (let attempt = 1; attempt <= options.maxAttempts; attempt += 1) {
+            attemptsRun = attempt;
+            if (attempt > 1 || (attempt === 1 && options.resetBeforeFirstAttempt)) {
+                console.log();
+                const resetTarget = attempt > 1
+                    ? `attempt ${attempt}/${options.maxAttempts}`
+                    : options.variationLabel;
+                console.log(chalk.dim(`  Resetting generated workspace state before ${resetTarget}...`));
+                resetWorkspaceGeneratedState(options.workspacePath, "compile");
+            }
+            const result = await compileWorkspaceWithReporter(options.executor, options.workspacePath, {
+                heading: options.maxAttempts > 1
+                    ? `Building compiled workspace (${options.variationLabel}, attempt ${attempt}/${options.maxAttempts})...`
+                    : `Building compiled workspace (${options.variationLabel})...`,
+                successMessage: options.maxAttempts > 1
+                    ? `Compiled workspace ready for ${options.variationLabel}, attempt ${attempt}.`
+                    : `Compiled workspace ready for ${options.variationLabel}.`,
+                preserveStageShells: options.preserveStageShells,
+            });
+            if (!result.ok) {
+                printCompileFailure(options.workspacePath, result.failedStage);
+                printStageShellReviewHint(options.workspacePath, options.preserveStageShells);
+                if (attempt < options.maxAttempts) {
+                    console.log(chalk.yellow(`  ${options.variationLabel} attempt ${attempt}/${options.maxAttempts} failed. Retrying with a fresh compile.`));
+                    continue;
+                }
+                return {
+                    passed: false,
+                    attemptsRun,
+                    failedStage: result.failedStage,
+                    bestOutcome,
+                    bestSnapshotPath,
+                    bestAttempt,
+                    fatalError: null,
+                };
+            }
+            const outcome = await runSavedWorkspaceTest({
+                sourcePath: options.sourcePath,
+                workspaceConfig: options.workspaceConfig,
+                executor: options.testExecutor,
+                executionProfile: options.executionProfile,
+                workspacePath: options.workspacePath,
+                preserveSandboxes: options.preserveStageShells === "always" ? "always" : "on-failure",
+            });
+            if (!outcome) {
+                return {
+                    passed: false,
+                    attemptsRun,
+                    failedStage: null,
+                    bestOutcome,
+                    bestSnapshotPath,
+                    bestAttempt,
+                    fatalError: "Could not run the saved workspace test after compile.",
+                };
+            }
+            console.log();
+            printSavedTestOutcome(`${options.variationLabel} · attempt ${attempt}/${options.maxAttempts}`, outcome);
+            if (!bestOutcome || testScore(outcome) > testScore(bestOutcome)) {
+                if (bestSnapshotPath) {
+                    rmSync(bestSnapshotPath, { recursive: true, force: true });
+                }
+                bestOutcome = outcome;
+                bestSnapshotPath = snapshotWorkspaceBestState(options.workspacePath);
+                bestAttempt = attempt;
+            }
+            if (outcome.result.ok) {
+                console.log();
+                console.log(chalk.green(`  Workspace passed on ${options.variationLabel}, attempt ${attempt}/${options.maxAttempts}.`));
+                printStageShellReviewHint(options.workspacePath, options.preserveStageShells);
+                return {
+                    passed: true,
+                    attemptsRun,
+                    failedStage: null,
+                    bestOutcome,
+                    bestSnapshotPath,
+                    bestAttempt,
+                    fatalError: null,
+                };
+            }
+            if (attempt < options.maxAttempts) {
+                console.log();
+                console.log(chalk.yellow(`  ${options.variationLabel} attempt ${attempt}/${options.maxAttempts} did not pass. Retrying with the same workflow.`));
+            }
+        }
+        return {
+            passed: false,
+            attemptsRun,
+            failedStage: null,
+            bestOutcome,
+            bestSnapshotPath,
+            bestAttempt,
+            fatalError: null,
+        };
+    }
+    catch (error) {
+        return {
+            passed: false,
+            attemptsRun,
+            failedStage: null,
+            bestOutcome,
+            bestSnapshotPath,
+            bestAttempt,
+            fatalError: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+function summarizeWorkflowVariation(options) {
+    const passedQuestions = options.result.bestOutcome?.result.passedCases ?? 0;
+    const totalQuestions = options.result.bestOutcome?.result.totalCases ?? options.defaultTotalQuestions;
+    const summary = options.result.passed
+        ? `Passed ${passedQuestions}/${totalQuestions} truth checks.`
+        : options.result.bestOutcome
+            ? `Best result: ${passedQuestions}/${totalQuestions} truth checks passed.`
+            : options.result.failedStage
+                ? `Compile failed at stage ${options.result.failedStage} before any test result.`
+                : "Workflow variation did not produce a passing result.";
+    return {
+        variation: options.variation,
+        kind: options.kind,
+        attempts_run: Math.max(1, options.result.attemptsRun),
+        passed: options.result.passed,
+        passed_questions: passedQuestions,
+        total_questions: totalQuestions,
+        ...(options.result.failedStage ? { failed_stage: options.result.failedStage } : {}),
+        ...(options.result.bestOutcome ? { test_run_path: options.result.bestOutcome.runPath } : {}),
+        ...(options.result.bestOutcome?.result.sandbox_path
+            ? { test_sandbox_path: options.result.bestOutcome.result.sandbox_path }
+            : {}),
+        summary,
+    };
+}
+function printStageShellReviewHint(workspacePath, preserveStageShells) {
+    const reviewRoot = stageExecutionShellsRoot(workspacePath);
+    if (preserveStageShells === "always") {
+        console.log(chalk.dim(`  Preserved stage shells: ${reviewRoot}`));
+        return;
+    }
+    console.log(chalk.dim(`  Failed stage shells remain under: ${reviewRoot}`));
+}
+function formatVariationQuestionSummary(summary) {
+    return `${summary.passed_questions}/${summary.total_questions}`;
+}
+function printWorkflowVariationSummary(summaries) {
+    if (summaries.length === 0)
+        return;
+    console.log();
+    console.log(chalk.bold("  Workflow variation summary"));
+    console.log();
+    console.log("  | Variation | Kind | Truth checks | Result |");
+    console.log("  | --- | --- | --- | --- |");
+    for (const summary of summaries) {
+        console.log(`  | ${summary.variation} | ${summary.kind} | \`${formatVariationQuestionSummary(summary)}\` | ${summary.passed ? "pass" : "fail"} |`);
+    }
+}
+function printWorkspaceLocalWorkflowOwnership(workspacePath, bestVariation) {
+    if (bestVariation <= 1)
+        return;
+    console.log();
+    console.log(chalk.dim(`  Best workflow variation now lives in: ${workflowPackagePathForWorkspace(workspacePath)}`));
+    console.log(chalk.dim("  Source-folder workflow selection was not changed automatically."));
+    console.log(chalk.dim("  Recompiling this existing workspace reuses that workspace-local workflow draft."));
+}
+export async function runConfiguredWorkspaceCompile(options) {
+    const preserveStageShells = options.preserveStageShells ?? "on-failure";
+    const configuredMaxAttempts = resolveWorkspaceCompileMaxAttempts(options.workspaceConfig ?? { max_attempts: undefined }, options.maxAttemptsOverride);
+    const maxLoops = resolveWorkspaceCompileMaxLoops(options.workspaceConfig ?? { max_loops: undefined }, options.maxLoopsOverride);
+    const maxAttempts = configuredMaxAttempts ?? (maxLoops != null ? 1 : null);
+    const loopEnabled = maxAttempts != null;
+    const checks = options.workspaceConfig?.checks ?? [];
+    if (loopEnabled && checks.length === 0) {
+        console.log(chalk.yellow("  Retry and self-improving modes need saved truth checks. Building once without those loops."));
+    }
+    else if (loopEnabled) {
+        if (maxAttempts > 1) {
+            console.log(chalk.dim(`  Retry mode: up to ${maxAttempts} compile attempts.`));
+            console.log(chalk.dim("  Interf Compiler will rerun the same workflow variation, test the workspace, and stop early if it passes."));
+        }
+        else {
+            console.log(chalk.dim("  Compile mode: 1 attempt per workflow variation."));
+        }
+        if (maxLoops != null) {
+            console.log(chalk.dim(`  Self-improving loops: up to ${maxLoops} workflow edits after retries fail.`));
+            console.log(chalk.dim("  Interf Compiler will review failed runs, edit the workflow package, and test new workflow variations."));
+        }
+    }
+    if (!loopEnabled || checks.length === 0) {
+        const result = await compileWorkspaceWithReporter(options.executor, options.workspacePath, {
+            preserveStageShells,
+        });
+        if (!result.ok) {
+            process.exitCode = 1;
+            printCompileFailure(options.workspacePath, result.failedStage);
+            printStageShellReviewHint(options.workspacePath, preserveStageShells);
+            return false;
+        }
+        printStageShellReviewHint(options.workspacePath, preserveStageShells);
+        return true;
+    }
+    let bestOutcome = null;
+    let bestSnapshotPath = null;
+    let bestAttempt = 0;
+    let bestVariation = 0;
+    const previousVariations = [];
+    const improvementRunId = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+    try {
+        const workspaceConfig = options.workspaceConfig ?? {
+            name: readInterfConfig(options.workspacePath)?.name ?? "workspace",
+            checks: [],
+        };
+        const adoptVariationBest = (variation, result) => {
+            if (result.bestOutcome && result.bestSnapshotPath && (!bestOutcome || testScore(result.bestOutcome) > testScore(bestOutcome))) {
+                if (bestSnapshotPath) {
+                    rmSync(bestSnapshotPath, { recursive: true, force: true });
+                }
+                bestOutcome = result.bestOutcome;
+                bestSnapshotPath = result.bestSnapshotPath;
+                bestAttempt = result.bestAttempt;
+                bestVariation = variation;
+                result.bestSnapshotPath = null;
+            }
+            if (result.bestSnapshotPath) {
+                rmSync(result.bestSnapshotPath, { recursive: true, force: true });
+                result.bestSnapshotPath = null;
+            }
+        };
+        const baseline = await runWorkflowVariation({
+            executor: options.executor,
+            testExecutor: options.testExecutor,
+            workspacePath: options.workspacePath,
+            sourcePath: options.sourcePath,
+            workspaceConfig,
+            executionProfile: options.executionProfile,
+            preserveStageShells,
+            maxAttempts,
+            variationLabel: "baseline workflow",
+        });
+        if (baseline.fatalError) {
+            process.exitCode = 1;
+            console.log(chalk.red(`  ${baseline.fatalError}`));
+            return false;
+        }
+        adoptVariationBest(1, baseline);
+        previousVariations.push(summarizeWorkflowVariation({
+            variation: 1,
+            kind: "baseline",
+            result: baseline,
+            defaultTotalQuestions: checks.length,
+        }));
+        if (baseline.passed) {
+            printWorkflowVariationSummary(previousVariations);
+            return true;
+        }
+        if (maxLoops != null) {
+            for (let loopIndex = 1; loopIndex <= maxLoops; loopIndex += 1) {
+                console.log();
+                console.log(chalk.dim(`  Self-improving loop ${loopIndex}/${maxLoops}: reviewing failed runs and editing the workflow.`));
+                const improvement = await runWorkflowImprovementLoop({
+                    executor: options.executor,
+                    workspacePath: options.workspacePath,
+                    workflowId: resolveWorkspaceWorkflowFromConfig(readInterfConfig(options.workspacePath)),
+                    workspaceConfig,
+                    runId: improvementRunId,
+                    loopIndex,
+                    maxLoops,
+                    maxAttempts,
+                    previousVariations,
+                });
+                console.log(chalk.dim(`  Workflow improvement shell: ${improvement.shellPath}`));
+                if (improvement.status === "executor-failed") {
+                    process.exitCode = 1;
+                    console.log(chalk.red(`  ${improvement.summary}`));
+                    break;
+                }
+                if (improvement.status !== "updated") {
+                    console.log(chalk.yellow(`  ${improvement.summary}`));
+                    continue;
+                }
+                const variation = await runWorkflowVariation({
+                    executor: options.executor,
+                    testExecutor: options.testExecutor,
+                    workspacePath: options.workspacePath,
+                    sourcePath: options.sourcePath,
+                    workspaceConfig,
+                    executionProfile: options.executionProfile,
+                    preserveStageShells,
+                    maxAttempts,
+                    variationLabel: `workflow variation ${loopIndex + 1}`,
+                    resetBeforeFirstAttempt: true,
+                });
+                if (variation.fatalError) {
+                    process.exitCode = 1;
+                    console.log(chalk.red(`  ${variation.fatalError}`));
+                    return false;
+                }
+                adoptVariationBest(loopIndex + 1, variation);
+                previousVariations.push(summarizeWorkflowVariation({
+                    variation: loopIndex + 1,
+                    kind: "edited",
+                    result: variation,
+                    defaultTotalQuestions: checks.length,
+                }));
+                if (variation.passed) {
+                    printWorkflowVariationSummary(previousVariations);
+                    printWorkspaceLocalWorkflowOwnership(options.workspacePath, bestVariation);
+                    return true;
+                }
+            }
+        }
+        if (bestSnapshotPath && bestVariation > 0) {
+            restoreWorkspaceBestState(bestSnapshotPath, options.workspacePath);
+            console.log();
+            console.log(chalk.dim(`  Restored the best-performing compiled workspace from variation ${bestVariation}, attempt ${bestAttempt}.`));
+        }
+        process.exitCode = 1;
+        console.log();
+        printWorkflowVariationSummary(previousVariations);
+        printWorkspaceLocalWorkflowOwnership(options.workspacePath, bestVariation);
+        if (maxLoops != null) {
+            console.log(chalk.red(`  Workspace did not pass after ${maxAttempts} attempt${maxAttempts === 1 ? "" : "s"} per variation and ${maxLoops} workflow-improvement loop${maxLoops === 1 ? "" : "s"}.`));
+        }
+        else {
+            console.log(chalk.red(`  Workspace did not pass within ${maxAttempts} attempt${maxAttempts === 1 ? "" : "s"}.`));
+        }
+        if (bestOutcome) {
+            console.log(chalk.dim(`  Best attempt truth-check pass rate: ${questionPassRate(bestOutcome)}%.`));
+        }
+        printStageShellReviewHint(options.workspacePath, preserveStageShells);
+        return false;
+    }
+    finally {
+        if (bestSnapshotPath) {
+            rmSync(bestSnapshotPath, { recursive: true, force: true });
+        }
+    }
+}

package/dist/commands/compile.d.ts

@@ -1,16 +1,15 @@
-import type { WorkflowExecutionProfile, WorkflowExecutor } from "../lib/executors.js";
 import type { SourceWorkspaceConfig } from "../lib/schema.js";
 import type { CommandModule } from "yargs";
-import type { StageShellRetentionMode } from "../lib/workflows.js";
+export { runConfiguredWorkspaceCompile } from "./compile-controller.js";
 export declare const compileCommand: CommandModule;
 export declare function runCompileCommand(argv?: Record<string, unknown>): Promise<void>;
-export declare function runConfiguredWorkspaceCompile(options: {
-    executor: WorkflowExecutor;
+export declare function resolveInteractiveCompileLoopOverrides(options: {
     workspacePath: string;
-    sourcePath: string;
     workspaceConfig: SourceWorkspaceConfig | null;
-    executionProfile?: WorkflowExecutionProfile;
     maxAttemptsOverride: number | null;
-    preserveStageShells?: StageShellRetentionMode;
-}): Promise<boolean>;
-//# sourceMappingURL=compile.d.ts.map
+    maxLoopsOverride: number | null;
+}): Promise<{
+    workspaceConfig: SourceWorkspaceConfig | null;
+    maxAttemptsOverride: number | null;
+    maxLoopsOverride: number | null;
+} | null>;