@interf/compiler 0.5.1 → 0.6.3

package/dist/lib/workflow-stage-runner.d.ts

@@ -1,41 +1 @@
-import { type WorkflowExecutor } from "./executors.js";
-import { type RuntimeContractType, type RuntimeStageInstructions } from "./schema.js";
-import { type RuntimeStageContractDraft } from "./runtime.js";
-import { type WorkflowReporter, type WorkflowStageResult } from "./workflow-helpers.js";
-interface WorkflowStageShape<TContractType extends RuntimeContractType> {
-    id: string;
-    label: string;
-    contractType: TContractType;
-}
-interface ExecuteValidatedStageOptions<TContractType extends RuntimeContractType> {
-    executor: WorkflowExecutor;
-    compiledPath: string;
-    executionPath?: string;
-    targetName: string;
-    workflow: string;
-    workflowSourcePath?: string;
-    stageDefinition: WorkflowStageShape<TContractType>;
-    instructions: RuntimeStageInstructions;
-    summary: string;
-    contract: RuntimeStageContractDraft;
-    statusLines: string[];
-    reporter?: WorkflowReporter;
-    completionCheck?: (() => boolean) | null;
-    syncWrites?: (() => void) | null;
-    reconcile?: (() => boolean) | null;
-    refreshArtifacts?: (() => void) | null;
-    validate: () => {
-        ok: boolean;
-        summary: string;
-    };
-}
-interface ExecuteValidatedSummarizeStageOptions<TContractType extends RuntimeContractType> extends ExecuteValidatedStageOptions<TContractType> {
-    startingSummaryCount: number;
-    targetCount: number;
-}
-export declare function findStageByContractType<TStage extends {
-    contractType: string;
-}>(stages: TStage[], contractType: TStage["contractType"]): TStage;
-export declare function executeValidatedStage<TContractType extends RuntimeContractType>(options: ExecuteValidatedStageOptions<TContractType>): Promise<WorkflowStageResult>;
-export declare function executeValidatedSummarizeStage<TContractType extends RuntimeContractType>(options: ExecuteValidatedSummarizeStageOptions<TContractType>): Promise<WorkflowStageResult>;
-export {};
+export * from "../packages/workflow-package/workflow-stage-runner.js";

package/dist/lib/workflow-stage-runner.js

@@ -1,109 +1 @@
-import { markRuntimeRunSucceededAfterValidation, buildStagePrompt, markRuntimeRunFailedAfterValidation, runExecutorStage, runExecutorSummarizeStage, } from "./runtime.js";
-import { reportValidationFailure, validateStageOutcome, } from "./workflow-helpers.js";
-export function findStageByContractType(stages, contractType) {
-    const stage = stages.find((candidate) => candidate.contractType === contractType);
-    if (!stage) {
-        throw new Error(`Missing workflow stage for contract type: ${contractType}`);
-    }
-    return stage;
-}
-export async function executeValidatedStage(options) {
-    const completionCheck = options.completionCheck
-        ? () => {
-            options.syncWrites?.();
-            options.reconcile?.();
-            return options.completionCheck?.() === true;
-        }
-        : undefined;
-    const code = await runExecutorStage({
-        executor: options.executor,
-        compiledPath: options.compiledPath,
-        executionPath: options.executionPath,
-        compiledName: options.targetName,
-        workflow: options.workflow,
-        workflowSourcePath: options.workflowSourcePath,
-        stage: options.stageDefinition.id,
-        stageLabel: options.stageDefinition.label,
-        contractType: options.stageDefinition.contractType,
-        summary: options.summary,
-        contract: options.contract,
-        buildPrompt: (contractPath) => buildStagePrompt(options.instructions, contractPath, options.statusLines),
-        completionCheck,
-    });
-    return finalizeValidatedStage(options, code);
-}
-export async function executeValidatedSummarizeStage(options) {
-    const completionCheck = options.completionCheck
-        ? () => {
-            options.syncWrites?.();
-            options.reconcile?.();
-            return options.completionCheck?.() === true;
-        }
-        : undefined;
-    const code = await runExecutorSummarizeStage({
-        executor: options.executor,
-        compiledPath: options.compiledPath,
-        executionPath: options.executionPath,
-        compiledName: options.targetName,
-        workflow: options.workflow,
-        workflowSourcePath: options.workflowSourcePath,
-        stage: options.stageDefinition.id,
-        stageLabel: options.stageDefinition.label,
-        contractType: options.stageDefinition.contractType,
-        summary: options.summary,
-        contract: options.contract,
-        buildPrompt: (contractPath) => buildStagePrompt(options.instructions, contractPath, options.statusLines),
-        completionCheck,
-        startingSummaryCount: options.startingSummaryCount,
-        targetCount: options.targetCount,
-    });
-    return finalizeValidatedStage(options, code);
-}
-function finalizeValidatedStage(options, code) {
-    const refreshAndValidate = () => {
-        options.syncWrites?.();
-        options.reconcile?.();
-        options.refreshArtifacts?.();
-        return validateStageOutcome(options.compiledPath, options.validate());
-    };
-    if (code !== 0) {
-        let completionSatisfied = false;
-        try {
-            options.syncWrites?.();
-            options.reconcile?.();
-            completionSatisfied = options.completionCheck?.() === true;
-        }
-        catch {
-            completionSatisfied = false;
-        }
-        if (completionSatisfied) {
-            const validation = refreshAndValidate();
-            if (validation.ok) {
-                markRuntimeRunSucceededAfterValidation(options.compiledPath, validation.summary);
-                return {
-                    ok: true,
-                    code: 0,
-                    summary: validation.summary,
-                };
-            }
-            reportValidationFailure(options.reporter, validation.summary);
-            markRuntimeRunFailedAfterValidation(options.compiledPath, validation.summary);
-            return {
-                ok: false,
-                code,
-                summary: validation.summary,
-            };
-        }
-        return { ok: false, code };
-    }
-    const validation = refreshAndValidate();
-    if (!validation.ok) {
-        reportValidationFailure(options.reporter, validation.summary);
-        markRuntimeRunFailedAfterValidation(options.compiledPath, validation.summary);
-    }
-    return {
-        ok: validation.ok,
-        code: validation.ok ? 0 : 1,
-        summary: validation.summary,
-    };
-}
+export * from "../packages/workflow-package/workflow-stage-runner.js";

package/dist/lib/workflows.d.ts

@@ -1,15 +1 @@
-import { type InterfConfig } from "./interf.js";
-export type { WorkflowReporter, WorkflowStageResult, LocalSkillContractExtension } from "./workflow-helpers.js";
-export { workflowQueryDirectory, workflowImproveDirectory, workflowCompileStageDirectory, emptyLocalSkillContractExtension, buildLocalSkillContractExtension, buildLocalSkillContractExtensionRelativeTo, mergeLocalSkillContractExtensions, buildStageInstructions, reportLine, reportBlankLine, reportValidationFailure, resolveStageAcceptance, validateStageOutcome, } from "./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";
+export * from "../packages/compiler/workflows.js";

package/dist/lib/workflows.js

@@ -1,31 +1 @@
-import { createCompiled as createCompiledScaffold, } from "./interf.js";
-import { detectInterf } from "./interf.js";
-import { validateCompiledCompile, } from "./validate.js";
-export { workflowQueryDirectory, workflowImproveDirectory, workflowCompileStageDirectory, emptyLocalSkillContractExtension, buildLocalSkillContractExtension, buildLocalSkillContractExtensionRelativeTo, mergeLocalSkillContractExtensions, buildStageInstructions, reportLine, reportBlankLine, reportValidationFailure, resolveStageAcceptance, validateStageOutcome, } from "./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";
+export * from "../packages/compiler/workflows.js";

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

@@ -0,0 +1,17 @@
+export * as args from "./lib/args.js";
+export * as constants from "./lib/constants.js";
+export * as detection from "./lib/detection.js";
+export * as execution from "./lib/execution.js";
+export * as logs from "./lib/logs.js";
+export * as preflight from "./lib/preflight.js";
+export * as render from "./lib/render.js";
+export * as shells from "./lib/shells.js";
+export * as status from "./lib/status.js";
+export * as types from "./lib/types.js";
+export * as agents from "./lib/agents.js";
+export * as executionProfile from "./lib/execution-profile.js";
+export * as executors from "./lib/executors.js";
+export * as schema from "./lib/schema.js";
+export * as userConfig from "./lib/user-config.js";
+export type { Agent, } from "./lib/types.js";
+export type { WorkflowExecutionProfile, WorkflowExecutor, WorkflowExecutorKind, } from "./lib/executors.js";

package/dist/packages/agents/index.js

@@ -0,0 +1,15 @@
+export * as args from "./lib/args.js";
+export * as constants from "./lib/constants.js";
+export * as detection from "./lib/detection.js";
+export * as execution from "./lib/execution.js";
+export * as logs from "./lib/logs.js";
+export * as preflight from "./lib/preflight.js";
+export * as render from "./lib/render.js";
+export * as shells from "./lib/shells.js";
+export * as status from "./lib/status.js";
+export * as types from "./lib/types.js";
+export * as agents from "./lib/agents.js";
+export * as executionProfile from "./lib/execution-profile.js";
+export * as executors from "./lib/executors.js";
+export * as schema from "./lib/schema.js";
+export * as userConfig from "./lib/user-config.js";

package/dist/packages/agents/lib/agents.d.ts

@@ -0,0 +1,6 @@
+export type { Agent, AgentAutomationReadiness, AgentPreflightOptions, AgentPreflightResult, SpawnAgentOptions, } from "./types.js";
+export { detectAgents, supportsAutomatedRuns, resolveAgent, } from "./detection.js";
+export { buildAgentPreflightPrompt, runAgentPreflight, ensureAgentAutomatedRunReady, } from "./preflight.js";
+export { spawnAgent, } from "./execution.js";
+export { buildAgentArgs, buildAgentEnv } from "./args.js";
+export { extractAgentFailureStatus, classifyTerminalVisibleStatus, hasAgentStalled, } from "./status.js";

package/dist/packages/agents/lib/agents.js

@@ -0,0 +1,5 @@
+export { detectAgents, supportsAutomatedRuns, resolveAgent, } from "./detection.js";
+export { buildAgentPreflightPrompt, runAgentPreflight, ensureAgentAutomatedRunReady, } from "./preflight.js";
+export { spawnAgent, } from "./execution.js";
+export { buildAgentArgs, buildAgentEnv } from "./args.js";
+export { extractAgentFailureStatus, classifyTerminalVisibleStatus, hasAgentStalled, } from "./status.js";

package/dist/packages/agents/lib/args.d.ts

@@ -0,0 +1,4 @@
+import type { WorkflowExecutionProfile } from "./executors.js";
+import type { Agent } from "./types.js";
+export declare function buildAgentEnv(agent: Agent, baseEnv?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+export declare function buildAgentArgs(agent: Agent, prompt: string, executionProfile?: WorkflowExecutionProfile): string[];

package/dist/packages/agents/lib/args.js

@@ -0,0 +1,52 @@
+const CODEX_SANDBOX_MODE = `work${"space-write"}`;
+export function buildAgentEnv(agent, baseEnv = process.env) {
+    const env = { ...baseEnv };
+    if (agent.name === "codex") {
+        // Codex executes Bash-tool commands inside its own sandbox. Let Codex
+        // choose a sandbox-safe default shell instead of inheriting a host-only
+        // login shell path such as /bin/zsh.
+        delete env.SHELL;
+    }
+    return env;
+}
+export function buildAgentArgs(agent, prompt, executionProfile = {}) {
+    if (agent.name === "claude-code") {
+        const args = [
+            "-p",
+            prompt,
+            "--output-format",
+            "stream-json",
+            "--verbose",
+            "--allowedTools",
+            "Read,Write,Edit,Bash,Grep,Glob,Agent",
+        ];
+        if (executionProfile.model) {
+            args.push("--model", executionProfile.model);
+        }
+        if (executionProfile.effort) {
+            args.push("--effort", executionProfile.effort);
+        }
+        return args;
+    }
+    if (agent.name === "codex") {
+        const args = [
+            "exec",
+            "--json",
+            "-s",
+            CODEX_SANDBOX_MODE,
+            "--skip-git-repo-check",
+        ];
+        if (executionProfile.model) {
+            args.push("--model", executionProfile.model);
+        }
+        if (executionProfile.profile) {
+            args.push("--profile", executionProfile.profile);
+        }
+        if (executionProfile.effort) {
+            args.push("-c", `model_reasoning_effort=${JSON.stringify(executionProfile.effort)}`);
+        }
+        args.push(prompt);
+        return args;
+    }
+    throw new Error(`Agent "${agent.displayName}" is not yet supported for automated compile runs.`);
+}

package/dist/packages/agents/lib/constants.d.ts

@@ -0,0 +1,5 @@
+import type { Agent } from "./types.js";
+export declare const SHOW_AGENT_TOOL_EVENTS: boolean;
+export declare const AGENTS: Agent[];
+export declare const CODEX_NOISE_PATTERNS: RegExp[];
+export declare const VISIBLE_STATUS_PREFIXES: string[];

package/dist/packages/agents/lib/constants.js

@@ -0,0 +1,28 @@
+import { join } from "node:path";
+import { homedir } from "node:os";
+export const SHOW_AGENT_TOOL_EVENTS = process.env.INTERF_DEBUG_AGENT_TOOLS === "1";
+export const AGENTS = [
+    {
+        name: "claude-code",
+        displayName: "Claude Code",
+        skillsDir: join(homedir(), ".claude", "skills"),
+        command: "claude",
+    },
+    {
+        name: "codex",
+        displayName: "Codex",
+        skillsDir: join(homedir(), ".codex", "skills"),
+        command: "codex",
+    },
+    {
+        name: "cursor",
+        displayName: "Cursor",
+        skillsDir: join(homedir(), ".cursor", "skills"),
+        command: "cursor",
+    },
+];
+export const CODEX_NOISE_PATTERNS = [
+    /codex_core_skills::loader: failed to stat skills entry .*\/(interf-[^ ]+|compiled\/[^ ]+) \(symlink\): No such file or directory/,
+    /codex_core::codex: failed to load skill .*\/gstack\/SKILL\.md: invalid description: exceeds maximum length of 1024 characters/,
+];
+export const VISIBLE_STATUS_PREFIXES = ["STATUS:", "DONE:", "BLOCKED:", "ERROR:"];

package/dist/packages/agents/lib/detection.d.ts

@@ -0,0 +1,7 @@
+import type { Agent } from "./types.js";
+export declare function detectAgents(): Agent[];
+export declare function supportsAutomatedRuns(agent: Agent): boolean;
+export declare function resolveAgent(): {
+    agent: Agent | null;
+    error?: string;
+};

package/dist/packages/agents/lib/detection.js

@@ -0,0 +1,65 @@
+import { existsSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { loadUserConfig } from "./user-config.js";
+import { AGENTS } from "./constants.js";
+export function detectAgents() {
+    return AGENTS.filter((agent) => {
+        const dir = join(homedir(), `.${agent.name === "claude-code" ? "claude" : agent.name}`);
+        return existsSync(dir);
+    });
+}
+function commandExists(command) {
+    try {
+        execFileSync("which", [command], { stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function supportsAutomatedRuns(agent) {
+    return agent.name === "claude-code" || agent.name === "codex";
+}
+export function resolveAgent() {
+    const config = loadUserConfig();
+    if (config) {
+        const configured = AGENTS.find((agent) => agent.command === config.agentCommand) ??
+            AGENTS.find((agent) => agent.name === config.agent) ??
+            AGENTS.find((agent) => agent.displayName === config.agent);
+        if (!configured) {
+            return {
+                agent: null,
+                error: `Configured agent "${config.agent}" is not supported by this Interf build. Run \`interf\` or \`interf init\` to choose a supported agent.`,
+            };
+        }
+        if (!commandExists(configured.command)) {
+            return {
+                agent: null,
+                error: `Configured agent "${configured.displayName}" is not available in PATH. Run \`interf\` or \`interf init\` to reconfigure.`,
+            };
+        }
+        if (!supportsAutomatedRuns(configured)) {
+            return {
+                agent: null,
+                error: `Configured agent "${configured.displayName}" is detected, but this Interf build can only automate Claude Code or Codex. Run \`interf\` or \`interf init\` and choose one of those agents.`,
+            };
+        }
+        return { agent: configured };
+    }
+    const detected = detectAgents().filter((agent) => commandExists(agent.command) && supportsAutomatedRuns(agent));
+    if (detected.length === 0) {
+        return {
+            agent: null,
+            error: "No coding agent detected. Install Claude Code or Codex.",
+        };
+    }
+    if (detected.length > 1) {
+        return {
+            agent: null,
+            error: "Multiple coding agents detected but no default is configured. Run `interf` or `interf init` to choose which agent local runs should use.",
+        };
+    }
+    return { agent: detected[0] };
+}

package/dist/packages/agents/lib/execution-profile.d.ts

@@ -0,0 +1,17 @@
+import type { Argv } from "yargs";
+import type { Agent } from "./types.js";
+import type { WorkflowExecutionProfile } from "./executors.js";
+type AgentLike = Pick<Agent, "name"> | string | null | undefined;
+export declare function addExecutionProfileOptions<T extends Argv>(yargs: T): T;
+type ExecutionProfileArgSource = Record<string, unknown> & {
+    model?: unknown;
+    profile?: unknown;
+    effort?: unknown;
+    timeoutMs?: unknown;
+    "timeout-ms"?: unknown;
+};
+export declare function executionProfileFromArgv(argv: ExecutionProfileArgSource): WorkflowExecutionProfile;
+export declare function applyInternalAcceptanceExecutionProfileDefaults(agent: AgentLike, overrides?: WorkflowExecutionProfile): WorkflowExecutionProfile;
+export declare function hasWorkflowExecutionProfile(profile: WorkflowExecutionProfile | null | undefined): boolean;
+export declare function formatWorkflowExecutionProfile(profile: WorkflowExecutionProfile | null | undefined): string | null;
+export {};

package/dist/packages/agents/lib/execution-profile.js

@@ -0,0 +1,84 @@
+const INTERNAL_ACCEPTANCE_DEFAULTS = {
+    "claude-code": {
+        model: "claude-sonnet-4-6",
+        effort: "low",
+    },
+    codex: {
+        model: "gpt-5.4-mini",
+        effort: "low",
+    },
+};
+function readAgentName(agent) {
+    if (!agent)
+        return null;
+    return typeof agent === "string" ? agent : agent.name;
+}
+function normalizeOptionalString(value) {
+    if (typeof value !== "string")
+        return null;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function normalizeOptionalTimeout(value) {
+    if (value === undefined || value === null || value === "")
+        return null;
+    const parsed = typeof value === "number" ? value : Number.parseInt(String(value), 10);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        throw new Error(`Invalid timeout: ${String(value)}`);
+    }
+    return parsed;
+}
+export function addExecutionProfileOptions(yargs) {
+    return yargs
+        .option("model", {
+        type: "string",
+        describe: "Override the local executor model for this run",
+    })
+        .option("profile", {
+        type: "string",
+        describe: "Executor-specific profile override for this run",
+    })
+        .option("effort", {
+        type: "string",
+        describe: "Override the model reasoning effort for this run",
+    })
+        .option("timeout-ms", {
+        type: "number",
+        describe: "Interrupt the local executor after this much inactivity",
+    });
+}
+export function executionProfileFromArgv(argv) {
+    return {
+        model: normalizeOptionalString(argv.model),
+        profile: normalizeOptionalString(argv.profile),
+        effort: normalizeOptionalString(argv.effort),
+        timeoutMs: normalizeOptionalTimeout(argv.timeoutMs ?? argv["timeout-ms"]),
+    };
+}
+export function applyInternalAcceptanceExecutionProfileDefaults(agent, overrides = {}) {
+    const defaults = INTERNAL_ACCEPTANCE_DEFAULTS[readAgentName(agent) ?? ""];
+    const profile = overrides.profile ?? null;
+    const explicitEffort = overrides.effort ?? null;
+    return {
+        model: overrides.model ?? defaults?.model ?? null,
+        profile,
+        effort: explicitEffort ?? (profile ? null : defaults?.effort ?? null),
+        timeoutMs: overrides.timeoutMs ?? null,
+    };
+}
+export function hasWorkflowExecutionProfile(profile) {
+    return Boolean(profile?.model ||
+        profile?.profile ||
+        profile?.effort ||
+        profile?.timeoutMs);
+}
+export function formatWorkflowExecutionProfile(profile) {
+    if (!hasWorkflowExecutionProfile(profile))
+        return null;
+    return JSON.stringify({
+        ...(profile?.model ? { model: profile.model } : {}),
+        ...(profile?.profile ? { profile: profile.profile } : {}),
+        ...(profile?.effort ? { effort: profile.effort } : {}),
+        ...(profile?.timeoutMs ? { timeout_ms: profile.timeoutMs } : {}),
+    });
+}

package/dist/packages/agents/lib/execution.d.ts

@@ -0,0 +1,2 @@
+import type { Agent, SpawnAgentOptions } from "./types.js";
+export declare function spawnAgent(agent: Agent, dirPath: string, prompt: string, options?: SpawnAgentOptions): Promise<number>;