@interf/compiler 0.4.0 → 0.5.0

package/dist/commands/create.js

@@ -1,22 +1,22 @@
 import chalk from "chalk";
 import { basename } from "node:path";
 import * as p from "@clack/prompts";
-import { detectInterf, defaultWorkspaceNameForSource, listWorkspacesForSourceFolder, } from "../lib/interf.js";
+import { detectInterf, defaultCompiledNameForSource, listCompiledDatasetsForSourceFolder, } from "../lib/interf.js";
 import { slugify } from "../lib/util.js";
 import { addExecutionProfileOptions, executionProfileFromArgv, } from "../lib/execution-profile.js";
-import { loadSourceFolderConfig, upsertSourceWorkspaceConfig } from "../lib/source-config.js";
-import { buildWorkspaceWorkflowOptions, chooseWorkspaceWorkflow, createWorkflowWizard, } from "./create-workflow-wizard.js";
-import { ensureWorkspaceFromConfig, } from "./workspace-flow.js";
-import { DEFAULT_WORKSPACE_NAME, promptSingleWorkspaceConfig, } from "./source-config-wizard.js";
+import { listSourceDatasetConfigs, loadSourceFolderConfig, upsertSourceDatasetConfig, } from "../lib/source-config.js";
+import { createWorkflowWizard, } from "./create-workflow-wizard.js";
+import { ensureCompiledFromConfig, } from "./compiled-flow.js";
+import { DEFAULT_COMPILED_NAME, promptSingleCompiledConfig, } from "./source-config-wizard.js";
 import { resolveOrConfigureLocalExecutor } from "./executor-flow.js";
-import { runConfiguredWorkspaceCompile } from "./compile.js";
+import { runConfiguredCompiledCompile } from "./compile.js";
 function normalizeCreateTarget(value) {
     if (!value)
         return null;
     switch (value) {
-        case "workspace":
-        case "ws":
-            return "workspace";
+        case "dataset":
+        case "ds":
+            return "dataset";
         case "workflow":
         case "wf":
             return "workflow";
@@ -29,9 +29,9 @@ async function selectCreateTarget() {
         message: "Create what?",
         options: [
             {
-                value: "workspace",
-                label: "Workspace (Recommended)",
-                hint: "Create a compiled workspace for this dataset",
+                value: "dataset",
+                label: "Dataset (Recommended)",
+                hint: "Add one dataset entry to this project",
             },
             {
                 value: "workflow",
@@ -43,10 +43,10 @@ async function selectCreateTarget() {
 }
 export const createCommand = {
     command: "create [type]",
-    describe: "Create a compiled workspace or reusable workflow",
+    describe: "Create a dataset entry or reusable workflow",
     builder: (yargs) => addExecutionProfileOptions(yargs.positional("type", {
         type: "string",
-        describe: "Type to create (`workspace` or `workflow`)",
+        describe: "Type to create (`dataset` or `workflow`)",
         default: undefined,
     })),
     handler: async (argv) => {
@@ -68,39 +68,32 @@ export const createCommand = {
             await createWorkflowWizard({ sourcePath: process.cwd() });
             return;
         }
-        await createWorkspaceWizard({ executionProfile });
+        await createCompiledWizard({ executionProfile });
     },
 };
-export async function createWorkspaceWizard(options = {}) {
+export async function createCompiledWizard(options = {}) {
     if (options.intro !== false) {
-        p.intro(chalk.bold("Create a workspace"));
+        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 workspace.");
+        p.log.error("You are already inside a compiled dataset.");
         return;
     }
-    const existing = listWorkspacesForSourceFolder(cwd);
+    const existing = listCompiledDatasetsForSourceFolder(cwd);
     if (existing.length > 0) {
-        p.log.info(`This dataset already has ${existing.length} workspace${existing.length === 1 ? "" : "s"}. Add another only when you need a separate set of truth checks or a different focus.`);
+        p.log.info(`This project already has ${existing.length} compiled dataset${existing.length === 1 ? "" : "s"}. Add another only when you need a separate folder, truth checks, or focus.`);
     }
-    p.log.info("Interf Compiler builds a compiled workspace on top of the dataset. The source files stay where they are and stay the source of truth.");
+    p.log.info("Interf Compiler measures one dataset at a time. Start with truth checks and a baseline, then build a compiled dataset only when you need it.");
     const existingConfig = loadSourceFolderConfig(cwd);
-    const suggestedName = slugify(defaultWorkspaceNameForSource(cwd) || basename(cwd)) || DEFAULT_WORKSPACE_NAME;
-    const workflowChoice = await chooseWorkspaceWorkflow(cwd, {
-        message: "Which workflow should this workspace start from?",
-    });
-    if (p.isCancel(workflowChoice))
-        return;
-    const workflowId = workflowChoice;
-    const workflowLabel = buildWorkspaceWorkflowOptions(cwd)
-        .find((option) => option.value === workflowId)?.label ?? workflowId;
-    const draft = await promptSingleWorkspaceConfig({
+    const suggestedName = slugify(defaultCompiledNameForSource(cwd) || basename(cwd)) || DEFAULT_COMPILED_NAME;
+    const workflowId = "interf";
+    const draft = await promptSingleCompiledConfig({
+        projectPath: cwd,
         initial: { name: suggestedName },
         introStyle: existingConfig ? "additional" : "first",
-        selectedWorkflowLabel: workflowLabel,
     });
     if (!draft)
         return;
@@ -108,34 +101,21 @@ export async function createWorkspaceWizard(options = {}) {
         ...draft,
         workflow: workflowId,
     };
-    const existingNames = new Set((existingConfig?.workspaces ?? []).map((workspace) => workspace.name));
+    const existingNames = new Set(listSourceDatasetConfigs(existingConfig).map((dataset) => dataset.name));
     if (existingNames.has(configToSave.name)) {
         process.exitCode = 1;
-        p.log.error(`Workspace "${configToSave.name}" already exists. Use \`interf\` or \`interf init\` to edit it.`);
-        return;
-    }
-    upsertSourceWorkspaceConfig(cwd, configToSave);
-    const spinner = p.spinner();
-    spinner.start("Creating workspace...");
-    let workspacePath = "";
-    try {
-        workspacePath = ensureWorkspaceFromConfig(cwd, configToSave);
-        spinner.stop("Workspace created.");
-    }
-    catch (error) {
-        spinner.stop("Workspace creation failed.");
-        process.exitCode = 1;
-        p.log.error(error instanceof Error ? error.message : String(error));
+        p.log.error(`Dataset "${configToSave.name}" already exists. Use \`interf\` or \`interf init\` to edit it.`);
         return;
     }
+    upsertSourceDatasetConfig(cwd, configToSave);
     const compileNow = await p.confirm({
-        message: "Build it now with this workflow and compile mode? (Recommended)",
+        message: "Build the compiled dataset now? (Recommended)",
         initialValue: true,
     });
     if (p.isCancel(compileNow) || !compileNow) {
         p.outro(configToSave.checks.length > 0
-            ? "Next:\n  interf compile\n  interf test"
-            : "Next:\n  interf compile\n  interf or interf init");
+            ? "Next:\n  interf test\n  interf compile"
+            : "Next:\n  interf or interf init");
         return;
     }
     const { executor, error } = await resolveOrConfigureLocalExecutor({
@@ -150,14 +130,27 @@ export async function createWorkspaceWizard(options = {}) {
         p.log.error(error ?? "No coding agent detected.");
         return;
     }
-    await compileWorkspaceAfterCreate(executor, cwd, configToSave, workspacePath, options.executionProfile);
+    const spinner = p.spinner();
+    spinner.start("Preparing compiled dataset...");
+    let compiledPath = "";
+    try {
+        compiledPath = ensureCompiledFromConfig(cwd, configToSave);
+        spinner.stop("Compiled dataset target ready.");
+    }
+    catch (error) {
+        spinner.stop("Compiled dataset target preparation failed.");
+        process.exitCode = 1;
+        p.log.error(error instanceof Error ? error.message : String(error));
+        return;
+    }
+    await compileCompiledAfterCreate(executor, cwd, configToSave, compiledPath, options.executionProfile);
 }
-async function compileWorkspaceAfterCreate(executor, sourcePath, workspaceConfig, workspacePath, executionProfile) {
-    const compiled = await runConfiguredWorkspaceCompile({
+async function compileCompiledAfterCreate(executor, sourcePath, datasetConfig, compiledPath, executionProfile) {
+    const compiled = await runConfiguredCompiledCompile({
         executor,
-        workspacePath,
+        compiledPath,
         sourcePath,
-        workspaceConfig,
+        compiledConfig: datasetConfig,
         executionProfile,
         maxAttemptsOverride: null,
         maxLoopsOverride: null,
@@ -166,4 +159,4 @@ async function compileWorkspaceAfterCreate(executor, sourcePath, workspaceConfig
         process.exitCode = 1;
     return compiled;
 }
-export { formatWorkflowLabel, chooseWorkspaceWorkflow, createWorkflowWizard, createWorkspaceWorkflowWizard, } from "./create-workflow-wizard.js";
+export { formatWorkflowLabel, chooseCompiledWorkflow, createWorkflowWizard, createCompiledWorkflowWizard, } from "./create-workflow-wizard.js";

package/dist/commands/default.js

@@ -5,7 +5,7 @@ function printStaticLanding() {
     const config = loadUserConfig();
     console.log();
     console.log(chalk.bold("  Interf Compiler"));
-    console.log(chalk.dim("  Set truth checks on a dataset, compile a workspace, and test whether it passes."));
+    console.log(chalk.dim("  Define truth checks, measure files-as-is, then compile only if it improves accuracy."));
     console.log();
     if (config) {
         console.log(chalk.dim(`  Agent: ${config.agent}`));
@@ -13,12 +13,12 @@ function printStaticLanding() {
     }
     console.log(chalk.dim("  Suggested flow:"));
     console.log(chalk.dim("    interf"));
+    console.log(chalk.dim("    interf test"));
     console.log(chalk.dim("    interf compile"));
     console.log(chalk.dim("    interf test"));
     console.log();
     console.log(chalk.dim("  More:"));
     console.log(chalk.dim("    interf init"));
-    console.log(chalk.dim("    interf create workspace"));
     console.log(chalk.dim("    interf create workflow"));
     console.log(chalk.dim("    interf doctor"));
     console.log(chalk.dim("    interf --help"));

package/dist/commands/executor-flow.d.ts

@@ -1,8 +1,27 @@
 import { type WorkflowExecutionProfile, type WorkflowExecutor } from "../lib/executors.js";
+export interface RunAgentOption {
+    name: string;
+    displayName: string;
+    command: string;
+    current: boolean;
+}
+export declare function resolvedConfiguredAgentName(): string | null;
+export declare function listRunAgentOptions(): RunAgentOption[];
+export declare function resolveNamedLocalExecutor(agentName: string, options?: {
+    preflight?: boolean;
+    executionProfile?: WorkflowExecutionProfile;
+}): {
+    executor: WorkflowExecutor | null;
+    error?: string;
+};
+export declare function promptForTestAgents(): Promise<{
+    agents: RunAgentOption[];
+    cancelled: boolean;
+}>;
 export declare function resolveOrConfigureLocalExecutor(options?: {
     preflight?: boolean;
     executionProfile?: WorkflowExecutionProfile;
-    purpose?: "compile" | "test";
+    purpose?: "compile" | "test" | "draft";
 }): Promise<{
     executor: WorkflowExecutor | null;
     error?: string;

package/dist/commands/executor-flow.js

@@ -1,13 +1,13 @@
 import * as p from "@clack/prompts";
 import { AGENTS } from "../lib/agent-constants.js";
-import { detectAgents, supportsAutomatedRuns } from "../lib/agents.js";
-import { resolveLocalExecutor, } from "../lib/executors.js";
+import { detectAgents, ensureAgentAutomatedRunReady, supportsAutomatedRuns } from "../lib/agents.js";
+import { createLocalAgentExecutor, resolveLocalExecutor, } from "../lib/executors.js";
 import { loadUserConfig, saveUserConfig } from "../lib/user-config.js";
 const promptedPurposes = new Set();
 function supportedDetectedAgents() {
     return detectAgents().filter((agent) => AGENTS.some((candidate) => candidate.name === agent.name) && supportsAutomatedRuns(agent));
 }
-function resolvedConfiguredAgentName() {
+export function resolvedConfiguredAgentName() {
     const current = loadUserConfig();
     if (!current)
         return null;
@@ -29,7 +29,67 @@ function persistSelectedAgent(selectedName) {
         initialized: current?.initialized ?? new Date().toISOString(),
     });
 }
+export function listRunAgentOptions() {
+    const configuredName = resolvedConfiguredAgentName();
+    return supportedDetectedAgents().map((agent) => ({
+        name: agent.name,
+        displayName: agent.displayName,
+        command: agent.command,
+        current: agent.name === configuredName,
+    }));
+}
+export function resolveNamedLocalExecutor(agentName, options = {}) {
+    const agent = supportedDetectedAgents().find((entry) => entry.name === agentName);
+    if (!agent) {
+        return { executor: null, error: `Local agent \"${agentName}\" is not detected.` };
+    }
+    if (options.preflight !== false) {
+        const readiness = ensureAgentAutomatedRunReady(agent);
+        if (!readiness.ok) {
+            return { executor: null, error: readiness.error };
+        }
+    }
+    return {
+        executor: createLocalAgentExecutor(agent, options.executionProfile),
+    };
+}
+export async function promptForTestAgents() {
+    const detected = listRunAgentOptions();
+    if (detected.length === 0)
+        return { agents: [], cancelled: false };
+    if (detected.length === 1) {
+        const only = detected[0];
+        if (only) {
+            persistSelectedAgent(only.name);
+            p.log.info(`Local agent for this test: ${only.displayName}`);
+            return { agents: [only], cancelled: false };
+        }
+    }
+    const current = detected.find((agent) => agent.current) ?? detected[0] ?? null;
+    const selected = await p.multiselect({
+        message: current
+            ? `Which local agents should run this test? Current: ${current.displayName}`
+            : "Which local agents should run this test?",
+        options: detected.map((agent) => ({
+            value: agent.name,
+            label: agent.current ? `${agent.displayName} (Current)` : agent.displayName,
+            hint: agent.command,
+        })),
+        required: false,
+        initialValues: current ? [current.name] : [],
+    });
+    if (p.isCancel(selected)) {
+        return { agents: [], cancelled: true };
+    }
+    const selectedNames = Array.isArray(selected) ? selected.map(String) : [];
+    const agents = detected.filter((agent) => selectedNames.includes(agent.name));
+    if (agents.length === 1 && agents[0]) {
+        persistSelectedAgent(agents[0].name);
+    }
+    return { agents, cancelled: false };
+}
 async function promptForRunAgent(purpose) {
+    const purposeLabel = purpose === "draft" ? "truth-check draft" : purpose;
     const detected = supportedDetectedAgents();
     if (detected.length === 0)
         return { selected: false, cancelled: false };
@@ -38,9 +98,9 @@ async function promptForRunAgent(purpose) {
         (detected.length === 1 ? detected[0] ?? null : null);
     let selectedName = null;
     if (detected.length === 1) {
-        p.log.info(`Local agent for this ${purpose}: ${detected[0]?.displayName ?? "unknown"}`);
+        p.log.info(`Local agent for this ${purposeLabel}: ${detected[0]?.displayName ?? "unknown"}`);
         const confirmed = await p.confirm({
-            message: `Run this ${purpose} with ${detected[0]?.displayName ?? "the detected agent"}?`,
+            message: `Run this ${purposeLabel} with ${detected[0]?.displayName ?? "the detected agent"}?`,
             initialValue: true,
         });
         if (p.isCancel(confirmed) || !confirmed) {
@@ -51,8 +111,8 @@ async function promptForRunAgent(purpose) {
     else {
         selectedName = await p.select({
             message: currentAgent
-                ? `Local agent for this ${purpose}? Current: ${currentAgent.displayName}`
-                : `Which local agent should run this ${purpose}?`,
+                ? `Local agent for this ${purposeLabel}? Current: ${currentAgent.displayName}`
+                : `Which local agent should run this ${purposeLabel}?`,
             options: detected.map((agent) => ({
                 value: agent.name,
                 label: agent.name === currentAgent?.name ? `${agent.displayName} (Current)` : agent.displayName,