@interf/compiler 0.5.1 → 0.6.3

package/dist/cli/commands/create.js

@@ -0,0 +1,166 @@
+import chalk from "chalk";
+import * as p from "@clack/prompts";
+import { detectInterf, resolveSourceControlPath, } from "../../packages/project-model/interf.js";
+import { addExecutionProfileOptions, executionProfileFromArgv, } from "../../packages/agents/lib/execution-profile.js";
+import { listSourceDatasetConfigs, loadSourceFolderConfig, syncCompiledInterfConfigFromSourceDatasetConfig, upsertSourceDatasetConfig, } from "../../packages/project-model/source-config.js";
+import { createWorkflowWizard, } from "./create-workflow-wizard.js";
+import { findBuiltCompiledPath, } from "./compiled-flow.js";
+import { DEFAULT_COMPILED_NAME, promptSingleCompiledConfig, } from "./source-config-wizard.js";
+function normalizeCreateTarget(value) {
+    if (!value)
+        return null;
+    switch (value) {
+        case "dataset":
+        case "ds":
+            return "dataset";
+        case "workflow":
+        case "wf":
+            return "workflow";
+        default:
+            return null;
+    }
+}
+async function selectCreateTarget() {
+    return p.select({
+        message: "Create what?",
+        options: [
+            {
+                value: "dataset",
+                label: "Dataset (Recommended)",
+                hint: "Add one dataset entry to this project",
+            },
+            {
+                value: "workflow",
+                label: "Workflow",
+                hint: "Create a reusable local workflow",
+            },
+        ],
+    });
+}
+async function maybeAssignWorkflowToDataset(sourcePath, workflowId) {
+    const config = loadSourceFolderConfig(sourcePath);
+    const datasets = listSourceDatasetConfigs(config);
+    if (datasets.length === 0) {
+        p.log.info(`Created workflow "${workflowId}".`);
+        p.log.info(`Next: run \`interf\`, add a setup, then assign workflow "${workflowId}" from that menu.`);
+        return;
+    }
+    const assignNow = await p.confirm({
+        message: "Assign this workflow to a dataset now? (Recommended)",
+        initialValue: true,
+    });
+    if (p.isCancel(assignNow) || !assignNow) {
+        p.log.info(`Created workflow "${workflowId}".`);
+        p.log.info(`Next: run \`interf\`, open a saved setup, and assign workflow "${workflowId}" from that menu.`);
+        return;
+    }
+    let targetDataset = datasets[0] ?? null;
+    if (datasets.length > 1) {
+        const selected = await p.select({
+            message: "Which source folder setup should use this workflow?",
+            options: datasets.map((dataset) => ({
+                value: dataset.name,
+                label: dataset.name,
+                hint: `${dataset.path} · ${dataset.about ?? `${dataset.checks.length} check${dataset.checks.length === 1 ? "" : "s"}`}`,
+            })),
+        });
+        if (p.isCancel(selected))
+            return;
+        targetDataset = datasets.find((dataset) => dataset.name === selected) ?? null;
+    }
+    if (!targetDataset)
+        return;
+    const nextConfig = {
+        ...targetDataset,
+        workflow: workflowId,
+    };
+    upsertSourceDatasetConfig(sourcePath, nextConfig, {
+        matchName: targetDataset.name,
+    });
+    const builtCompiledPath = findBuiltCompiledPath(sourcePath, targetDataset.name);
+    if (builtCompiledPath) {
+        syncCompiledInterfConfigFromSourceDatasetConfig(builtCompiledPath, nextConfig);
+    }
+    p.log.info(`Assigned workflow "${workflowId}" to dataset "${targetDataset.name}".`);
+    if (builtCompiledPath) {
+        p.log.info("The active local copy for that compiled context lives under `.interf/workflow/`.");
+    }
+    p.log.info("Next: run `interf compile`, then `interf test`.");
+}
+export const createCommand = {
+    command: "create [type]",
+    describe: "Create a dataset entry or reusable workflow",
+    builder: (yargs) => addExecutionProfileOptions(yargs.positional("type", {
+        type: "string",
+        describe: "Type to create (`dataset` or `workflow`)",
+        default: undefined,
+    })),
+    handler: async (argv) => {
+        const rawType = argv.type;
+        let type = normalizeCreateTarget(rawType);
+        const executionProfile = executionProfileFromArgv(argv);
+        if (rawType && !type) {
+            process.exitCode = 1;
+            p.log.error(`Unknown create target: ${rawType}`);
+            return;
+        }
+        if (!type) {
+            const selected = await selectCreateTarget();
+            if (p.isCancel(selected))
+                return;
+            type = selected;
+        }
+        if (type === "workflow") {
+            const detected = detectInterf(process.cwd());
+            const workflowId = await createWorkflowWizard({
+                sourcePath: detected ? resolveSourceControlPath(detected.path) : process.cwd(),
+                executionProfile,
+            });
+            if (typeof workflowId === "string") {
+                await maybeAssignWorkflowToDataset(detected ? resolveSourceControlPath(detected.path) : process.cwd(), workflowId);
+            }
+            return;
+        }
+        await createCompiledWizard({ executionProfile });
+    },
+};
+export async function createCompiledWizard(options = {}) {
+    if (options.intro !== false) {
+        p.intro(chalk.bold("Add a dataset"));
+    }
+    const cwd = process.cwd();
+    const detected = detectInterf(cwd);
+    if (detected) {
+        process.exitCode = 1;
+        p.log.error("You are already inside a compiled context.");
+        return;
+    }
+    const savedDatasets = listSourceDatasetConfigs(loadSourceFolderConfig(cwd));
+    if (savedDatasets.length > 0) {
+        p.log.info(`This project already has ${savedDatasets.length} saved setup${savedDatasets.length === 1 ? "" : "s"} in interf.json. Add another only when you need a separate folder, focus, or check set.`);
+    }
+    p.log.info("Interf works one source-folder setup at a time. Start with the task, the relevant files, and a few checks, then build a context folder when you want to prepare that task context for your agents.");
+    const existingConfig = loadSourceFolderConfig(cwd);
+    const draft = await promptSingleCompiledConfig({
+        projectPath: cwd,
+        initial: { name: DEFAULT_COMPILED_NAME },
+        introStyle: existingConfig ? "additional" : "first",
+    });
+    if (!draft)
+        return;
+    const configToSave = {
+        ...draft,
+        workflow: "interf",
+    };
+    const existingNames = new Set(listSourceDatasetConfigs(existingConfig).map((dataset) => dataset.name));
+    if (existingNames.has(configToSave.name)) {
+        process.exitCode = 1;
+        p.log.error(`Setup "${configToSave.name}" already exists. Use \`interf\` or \`interf init\` to edit it.`);
+        return;
+    }
+    upsertSourceDatasetConfig(cwd, configToSave);
+    p.outro(configToSave.checks.length > 0
+        ? "Saved dataset.\nNext:\n  interf test\n  interf compile"
+        : "Saved dataset.\nNext:\n  interf or interf init");
+}
+export { formatWorkflowLabel, createWorkflowWizard, createCompiledWorkflowWizard, } from "./create-workflow-wizard.js";

package/dist/cli/commands/dataset-selection.d.ts

@@ -0,0 +1,6 @@
+import type { SourceDatasetConfig } from "../../packages/project-model/lib/schema.js";
+export declare function resolveConfiguredDatasetSelection(options: {
+    sourcePath: string;
+    requestedDatasetName?: string | null;
+    hintedDatasetConfig?: SourceDatasetConfig | null;
+}): SourceDatasetConfig | null;

package/dist/cli/commands/dataset-selection.js

@@ -0,0 +1,11 @@
+import { findSavedCompiledConfig } from "./compiled-flow.js";
+export function resolveConfiguredDatasetSelection(options) {
+    if (options.hintedDatasetConfig &&
+        (!options.requestedDatasetName || options.hintedDatasetConfig.name === options.requestedDatasetName)) {
+        return options.hintedDatasetConfig;
+    }
+    if (!options.requestedDatasetName) {
+        return null;
+    }
+    return findSavedCompiledConfig(options.sourcePath, options.requestedDatasetName);
+}

package/dist/{commands → cli/commands}/default.js

@@ -1,11 +1,11 @@
 import chalk from "chalk";
-import { loadUserConfig } from "../lib/user-config.js";
+import { userConfig } from "../../packages/agents/index.js";
 import { runInitCommand } from "./init.js";
 function printStaticLanding() {
-    const config = loadUserConfig();
+    const config = userConfig.loadUserConfig();
     console.log();
-    console.log(chalk.bold("  Interf Compiler"));
-    console.log(chalk.dim("  Define truth checks, measure files-as-is, then compile only if it improves accuracy."));
+    console.log(chalk.bold("  Interf"));
+    console.log(chalk.dim("  Prepare task context for your agents from the files behind a task, then test it and use self-improving loops until the checks pass."));
     console.log();
     if (config) {
         console.log(chalk.dim(`  Agent: ${config.agent}`));
@@ -20,7 +20,7 @@ function printStaticLanding() {
     console.log(chalk.dim("  More:"));
     console.log(chalk.dim("    interf init"));
     console.log(chalk.dim("    interf create workflow"));
-    console.log(chalk.dim("    interf doctor"));
+    console.log(chalk.dim("    interf doctor --live"));
     console.log(chalk.dim("    interf --help"));
     console.log();
 }

package/dist/{commands → cli/commands}/doctor.js

@@ -1,6 +1,5 @@
 import chalk from "chalk";
-import { resolveAgent, runAgentPreflight } from "../lib/agents.js";
-import { loadUserConfig } from "../lib/user-config.js";
+import { agents, userConfig } from "../../packages/agents/index.js";
 function iconFor(status) {
     if (status === "pass")
         return chalk.green("✓");
@@ -12,7 +11,7 @@ function iconFor(status) {
 }
 export const doctorCommand = {
     command: "doctor",
-    describe: "Check local executor setup before a real compile",
+    describe: "Check local executor setup before a real local run",
     builder: (yargs) => yargs
         .option("live", {
         type: "boolean",
@@ -26,12 +25,12 @@ export const doctorCommand = {
     }),
     handler: async (argv) => {
         const checks = [];
-        const config = loadUserConfig();
-        const { agent, error } = resolveAgent();
+        const config = userConfig.loadUserConfig();
+        const { agent, error } = agents.resolveAgent();
         if (config) {
             checks.push({
                 id: "config",
-                label: "Interf Compiler setup",
+                label: "Interf setup",
                 status: "pass",
                 message: `Configured default agent: ${config.agent}`,
             });
@@ -39,9 +38,9 @@ export const doctorCommand = {
         else {
             checks.push({
                 id: "config",
-                label: "Interf Compiler setup",
+                label: "Interf setup",
                 status: "warn",
-                message: "No saved Interf Compiler setup found. `interf` or `interf init` is recommended for deterministic local runs.",
+                message: "No saved Interf setup found. `interf` or `interf init` is recommended for deterministic local runs.",
             });
         }
         if (!agent) {
@@ -56,7 +55,7 @@ export const doctorCommand = {
             }
             else {
                 console.log();
-                console.log(chalk.bold("  Interf Compiler doctor"));
+                console.log(chalk.bold("  Interf doctor"));
                 console.log();
                 for (const check of checks) {
                     console.log(`  ${iconFor(check.status)} ${check.label}: ${check.message}`);
@@ -73,13 +72,13 @@ export const doctorCommand = {
             message: `${agent.displayName} is configured and available as \`${agent.command}\``,
         });
         if (argv.live) {
-            const preflight = runAgentPreflight(agent);
+            const preflight = agents.runAgentPreflight(agent);
             checks.push({
                 id: "live",
                 label: "Live executor preflight",
                 status: preflight.ok ? "pass" : "fail",
                 message: preflight.ok
-                    ? `${agent.displayName} accepted Interf Compiler's automated run invocation`
+                    ? `${agent.displayName} accepted Interf's automated run invocation`
                     : preflight.timedOut
                         ? `${agent.displayName} timed out during preflight`
                         : preflight.error ?? `${agent.displayName} could not complete the preflight run`,
@@ -98,7 +97,7 @@ export const doctorCommand = {
                 id: "live",
                 label: "Live executor preflight",
                 status: "skipped",
-                message: "Skipped. Run `interf doctor --live` to exercise the real local agent before a compile.",
+                message: "Skipped. Run `interf doctor --live` to exercise the real local agent before a check draft, workflow authoring run, test, or compile.",
             });
         }
         const ok = checks.every((check) => check.status !== "fail");
@@ -115,7 +114,7 @@ export const doctorCommand = {
         }
         else {
             console.log();
-            console.log(chalk.bold("  Interf Compiler doctor"));
+            console.log(chalk.bold("  Interf doctor"));
             console.log();
             for (const check of checks) {
                 console.log(`  ${iconFor(check.status)} ${check.label}: ${check.message}`);

package/dist/{commands → cli/commands}/executor-flow.d.ts

@@ -1,4 +1,4 @@
-import { type WorkflowExecutionProfile, type WorkflowExecutor } from "../lib/executors.js";
+import { type WorkflowExecutionProfile, type WorkflowExecutor } from "../../packages/agents/index.js";
 export interface RunAgentOption {
     name: string;
     displayName: string;
@@ -21,7 +21,7 @@ export declare function promptForTestAgents(): Promise<{
 export declare function resolveOrConfigureLocalExecutor(options?: {
     preflight?: boolean;
     executionProfile?: WorkflowExecutionProfile;
-    purpose?: "compile" | "test" | "draft";
+    purpose?: "compile" | "test" | "draft" | "workflow";
 }): Promise<{
     executor: WorkflowExecutor | null;
     error?: string;

package/dist/{commands → cli/commands}/executor-flow.js

@@ -1,31 +1,27 @@
 import * as p from "@clack/prompts";
-import { AGENTS } from "../lib/agent-constants.js";
-import { detectAgents, ensureAgentAutomatedRunReady, supportsAutomatedRuns } from "../lib/agents.js";
-import { createLocalAgentExecutor, resolveLocalExecutor, } from "../lib/executors.js";
-import { loadUserConfig, saveUserConfig } from "../lib/user-config.js";
+import { constants, agents, executors, userConfig } from "../../packages/agents/index.js";
 const promptedPurposes = new Set();
 function supportedDetectedAgents() {
-    return detectAgents().filter((agent) => AGENTS.some((candidate) => candidate.name === agent.name) && supportsAutomatedRuns(agent));
+    return agents.detectAgents().filter((agent) => constants.AGENTS.some((candidate) => candidate.name === agent.name) && agents.supportsAutomatedRuns(agent));
 }
 export function resolvedConfiguredAgentName() {
-    const current = loadUserConfig();
+    const current = userConfig.loadUserConfig();
     if (!current)
         return null;
-    const configured = AGENTS.find((agent) => agent.command === current.agentCommand) ??
-        AGENTS.find((agent) => agent.name === current.agent) ??
-        AGENTS.find((agent) => agent.displayName === current.agent);
+    const configured = constants.AGENTS.find((agent) => agent.command === current.agentCommand) ??
+        constants.AGENTS.find((agent) => agent.name === current.agent) ??
+        constants.AGENTS.find((agent) => agent.displayName === current.agent);
     return configured?.name ?? null;
 }
 function persistSelectedAgent(selectedName) {
     const selected = supportedDetectedAgents().find((agent) => agent.name === selectedName);
     if (!selected)
         return;
-    const current = loadUserConfig();
-    saveUserConfig({
+    const current = userConfig.loadUserConfig();
+    userConfig.saveUserConfig({
         agent: selected.name,
         agentCommand: selected.command,
         skillsInstalled: current?.skillsInstalled ?? false,
-        ...(current?.viewer ? { viewer: current.viewer } : {}),
         initialized: current?.initialized ?? new Date().toISOString(),
     });
 }
@@ -44,13 +40,13 @@ export function resolveNamedLocalExecutor(agentName, options = {}) {
         return { executor: null, error: `Local agent \"${agentName}\" is not detected.` };
     }
     if (options.preflight !== false) {
-        const readiness = ensureAgentAutomatedRunReady(agent);
+        const readiness = agents.ensureAgentAutomatedRunReady(agent);
         if (!readiness.ok) {
             return { executor: null, error: readiness.error };
         }
     }
     return {
-        executor: createLocalAgentExecutor(agent, options.executionProfile),
+        executor: executors.createLocalAgentExecutor(agent, options.executionProfile),
     };
 }
 export async function promptForTestAgents() {
@@ -89,7 +85,11 @@ export async function promptForTestAgents() {
     return { agents, cancelled: false };
 }
 async function promptForRunAgent(purpose) {
-    const purposeLabel = purpose === "draft" ? "truth-check draft" : purpose;
+    const purposeLabel = purpose === "draft"
+        ? "check draft"
+        : purpose === "workflow"
+            ? "workflow authoring"
+            : purpose;
     const detected = supportedDetectedAgents();
     if (detected.length === 0)
         return { selected: false, cancelled: false };
@@ -144,7 +144,7 @@ export async function resolveOrConfigureLocalExecutor(options = {}) {
             return { executor: null, error: "No local agent detected." };
         }
     }
-    const resolved = resolveLocalExecutor(options);
+    const resolved = executors.resolveLocalExecutor(options);
     if (resolved.executor)
         return resolved;
     const needsChoice = typeof resolved.error === "string" &&
@@ -159,5 +159,5 @@ export async function resolveOrConfigureLocalExecutor(options = {}) {
     if (!configured.selected) {
         return resolved;
     }
-    return resolveLocalExecutor(options);
+    return executors.resolveLocalExecutor(options);
 }

package/dist/cli/commands/init.d.ts

@@ -0,0 +1,11 @@
+import type { CommandModule } from "yargs";
+import type { SourceDatasetConfig } from "../../packages/project-model/lib/schema.js";
+import { type AgentTestMatrixRow } from "./test-flow.js";
+import { runCompileCommand } from "./compile.js";
+export type CurrentRunTargetStatus = "pass" | "mixed" | "fail" | "missing";
+export declare function currentRunTargetStatus(rows: AgentTestMatrixRow[], target: "raw" | "compiled"): CurrentRunTargetStatus;
+export declare function compileSelectedCompiled(sourcePath: string, compiledConfig: SourceDatasetConfig, deps?: {
+    runCompileCommand?: typeof runCompileCommand;
+}): Promise<import("./compile.js").CompileCommandResult | null>;
+export declare const initCommand: CommandModule;
+export declare function runInitCommand(): Promise<void>;