@interf/compiler 0.7.3 → 0.9.3

package/dist/cli/commands/create.js

@@ -2,20 +2,21 @@ import chalk from "chalk";
 import * as p from "@clack/prompts";
 import { detectInterf, ensurePortableContextScaffold, resolveSourceControlPath, } from "../../packages/project-model/interf.js";
 import { addExecutionProfileOptions, executionProfileFromArgv, } from "../../packages/agents/lib/execution-profile.js";
-import { SOURCE_FOLDER_CONFIG_PATH, listSourceDatasetConfigs, loadSourceFolderConfig, syncCompiledInterfConfigFromSourceDatasetConfig, upsertSourceDatasetConfig, } from "../../packages/project-model/source-config.js";
-import { chooseOrCreateCompiledWorkflowForDataset, createWorkflowWizard, } from "./create-workflow-wizard.js";
+import { SOURCE_FOLDER_CONFIG_PATH, listSourcePreparationConfigs, loadSourceFolderConfig, syncCompiledInterfConfigFromSourcePreparationConfig, upsertSourcePreparationConfig, } from "../../packages/project-model/source-config.js";
+import { chooseOrCreateCompiledMethodForPreparation, createMethodWizard, } from "./create-method-wizard.js";
 import { findBuiltCompiledPath, } from "./compiled-flow.js";
-import { DEFAULT_COMPILED_NAME, promptSingleCompiledConfig, } from "./source-config-wizard.js";
+import { DEFAULT_PREPARATION_NAME, promptSingleCompiledConfig, } from "./source-config-wizard.js";
+import { defaultPreparationNameForPath, } from "../../packages/project-model/source-folders.js";
+import { resolveCommandControlPath, resolveInterfInstanceContext, } from "./control-path.js";
+import { resolveMethodId } from "../../packages/methods/method-resolution.js";
 function normalizeCreateTarget(value) {
     if (!value)
         return null;
     switch (value) {
-        case "dataset":
-        case "ds":
-            return "dataset";
-        case "workflow":
-        case "wf":
-            return "workflow";
+        case "preparation":
+            return "preparation";
+        case "method":
+            return "method";
         default:
             return null;
     }
@@ -25,77 +26,77 @@ async function selectCreateTarget() {
         message: "Create what?",
         options: [
             {
-                value: "dataset",
-                label: "Dataset (Recommended)",
-                hint: "Add one dataset entry to this project",
+                value: "preparation",
+                label: "Preparation (Recommended)",
+                hint: "Add one Preparation for this Source Folder",
             },
             {
-                value: "workflow",
-                label: "Workflow",
-                hint: "Create a reusable local workflow",
+                value: "method",
+                label: "Method",
+                hint: "Create a reusable local Method",
             },
         ],
     });
 }
-async function maybeAssignWorkflowToDataset(sourcePath, workflowId) {
+async function maybeAssignMethodToPreparation(sourcePath, methodId) {
     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.`);
+    const preparations = listSourcePreparationConfigs(config);
+    if (preparations.length === 0) {
+        p.log.info(`Created Method "${methodId}".`);
+        p.log.info(`Next: run \`interf\`, add a Preparation, then assign Method "${methodId}" from that menu.`);
         return;
     }
     const assignNow = await p.confirm({
-        message: "Assign this workflow to a dataset now? (Recommended)",
+        message: "Assign this Method to a Preparation 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.`);
+        p.log.info(`Created Method "${methodId}".`);
+        p.log.info(`Next: run \`interf\`, open a saved Preparation, and assign Method "${methodId}" from that menu.`);
         return;
     }
-    let targetDataset = datasets[0] ?? null;
-    if (datasets.length > 1) {
+    let targetPreparation = preparations[0] ?? null;
+    if (preparations.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} question${dataset.checks.length === 1 ? "" : "s"}`}`,
+            message: "Which saved Preparation should use this Method?",
+            options: preparations.map((preparation) => ({
+                value: preparation.name,
+                label: preparation.name,
+                hint: `${preparation.path} · ${preparation.about ?? `${preparation.checks.length} readiness check${preparation.checks.length === 1 ? "" : "s"}`}`,
             })),
         });
         if (p.isCancel(selected))
             return;
-        targetDataset = datasets.find((dataset) => dataset.name === selected) ?? null;
+        targetPreparation = preparations.find((preparation) => preparation.name === selected) ?? null;
     }
-    if (!targetDataset)
+    if (!targetPreparation)
         return;
     const nextConfig = {
-        ...targetDataset,
-        workflow: workflowId,
+        ...targetPreparation,
+        method: methodId,
     };
-    upsertSourceDatasetConfig(sourcePath, nextConfig, {
-        matchName: targetDataset.name,
+    upsertSourcePreparationConfig(sourcePath, nextConfig, {
+        matchName: targetPreparation.name,
     });
-    const builtCompiledPath = findBuiltCompiledPath(sourcePath, targetDataset.name);
+    const builtCompiledPath = findBuiltCompiledPath(sourcePath, targetPreparation.name);
     if (builtCompiledPath) {
-        syncCompiledInterfConfigFromSourceDatasetConfig(builtCompiledPath, nextConfig);
+        syncCompiledInterfConfigFromSourcePreparationConfig(builtCompiledPath, nextConfig);
     }
     else {
-        ensurePortableContextScaffold(sourcePath, nextConfig.name, nextConfig.workflow ?? "interf-default");
+        ensurePortableContextScaffold(sourcePath, nextConfig.name, resolveMethodId(nextConfig));
     }
-    p.log.info(`Assigned workflow "${workflowId}" to dataset "${targetDataset.name}".`);
+    p.log.info(`Assigned Method "${methodId}" to Preparation "${targetPreparation.name}".`);
     if (builtCompiledPath) {
-        p.log.info("The active local workflow copy for that portable context lives under `.interf/workflow/`.");
+        p.log.info("The active local Method copy for that Portable Context lives under `.interf/method/`.");
     }
     p.log.info("Next: run `interf compile`, then `interf test`.");
 }
 export const createCommand = {
     command: "create [type]",
-    describe: "Create a dataset entry or reusable workflow",
+    describe: "Create a Preparation or reusable Method",
     builder: (yargs) => addExecutionProfileOptions(yargs.positional("type", {
         type: "string",
-        describe: "Type to create (`dataset` or `workflow`)",
+        describe: "Type to create (`preparation` or `method`)",
         default: undefined,
     })),
     handler: async (argv) => {
@@ -113,14 +114,15 @@ export const createCommand = {
                 return;
             type = selected;
         }
-        if (type === "workflow") {
+        if (type === "method") {
             const detected = detectInterf(process.cwd());
-            const workflowId = await createWorkflowWizard({
-                sourcePath: detected ? resolveSourceControlPath(detected.path) : process.cwd(),
+            const sourcePath = detected ? resolveSourceControlPath(detected.path) : resolveCommandControlPath();
+            const methodId = await createMethodWizard({
+                sourcePath,
                 executionProfile,
             });
-            if (typeof workflowId === "string") {
-                await maybeAssignWorkflowToDataset(detected ? resolveSourceControlPath(detected.path) : process.cwd(), workflowId);
+            if (typeof methodId === "string") {
+                await maybeAssignMethodToPreparation(sourcePath, methodId);
             }
             return;
         }
@@ -129,48 +131,59 @@ export const createCommand = {
 };
 export async function createCompiledWizard(options = {}) {
     if (options.intro !== false) {
-        p.intro(chalk.bold("Add a dataset"));
+        p.intro(chalk.bold("Add a Preparation"));
     }
     const cwd = process.cwd();
     const detected = detectInterf(cwd);
     if (detected) {
         process.exitCode = 1;
-        p.log.error("You are already inside portable context.");
+        p.log.error("You are already inside Portable 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 ${SOURCE_FOLDER_CONFIG_PATH}. Add another only when you need a separate folder, focus, or question set.`);
+    const initContext = resolveInterfInstanceContext(cwd);
+    const sourcePath = initContext.controlPath;
+    const savedPreparations = listSourcePreparationConfigs(loadSourceFolderConfig(sourcePath));
+    if (savedPreparations.length > 0) {
+        p.log.info(`This Source Folder already has ${savedPreparations.length} saved Preparation${savedPreparations.length === 1 ? "" : "s"} in ${SOURCE_FOLDER_CONFIG_PATH}. Add another only when you need a separate Source Folder, agent-work focus, or readiness-check set.`);
     }
-    p.log.info("Interf works one source-folder setup at a time. Start with the work, the relevant files, and a few questions, then build portable context when you need evidence that the data is ready for agents.");
-    const existingConfig = loadSourceFolderConfig(cwd);
+    if (sourcePath !== cwd) {
+        p.log.info(`Interf Workspace: ${sourcePath}`);
+    }
+    p.log.info("Interf works one Preparation at a time. Start with the agent work, the relevant files, and a few readiness checks, then build Portable Context when you need evidence that the data is ready for agents.");
+    const existingConfig = loadSourceFolderConfig(sourcePath);
+    const initialConfig = initContext.defaultSourceFolderPath && initContext.defaultPreparationPath
+        ? {
+            name: defaultPreparationNameForPath(initContext.defaultSourceFolderPath),
+            path: initContext.defaultPreparationPath,
+        }
+        : { name: DEFAULT_PREPARATION_NAME };
     const draft = await promptSingleCompiledConfig({
-        projectPath: cwd,
-        initial: { name: DEFAULT_COMPILED_NAME },
+        projectPath: sourcePath,
+        initial: initialConfig,
         introStyle: existingConfig ? "additional" : "first",
     });
     if (!draft)
         return;
-    const existingNames = new Set(listSourceDatasetConfigs(existingConfig).map((dataset) => dataset.name));
+    const existingNames = new Set(listSourcePreparationConfigs(existingConfig).map((preparation) => preparation.name));
     if (existingNames.has(draft.name)) {
         process.exitCode = 1;
-        p.log.error(`Setup "${draft.name}" already exists. Use \`interf\` or \`interf init\` to edit it.`);
+        p.log.error(`Preparation "${draft.name}" already exists. Use \`interf\` or \`interf init\` to edit it.`);
         return;
     }
-    const workflowChoice = await chooseOrCreateCompiledWorkflowForDataset(cwd, draft, {
-        currentWorkflowId: "interf-default",
+    const methodChoice = await chooseOrCreateCompiledMethodForPreparation(sourcePath, draft, {
+        currentMethodId: "interf-default",
         executionProfile: options.executionProfile,
     });
-    if (!workflowChoice || p.isCancel(workflowChoice))
+    if (!methodChoice || p.isCancel(methodChoice))
         return;
     const configToSave = {
         ...draft,
-        workflow: String(workflowChoice),
+        method: String(methodChoice),
     };
-    upsertSourceDatasetConfig(cwd, configToSave);
-    ensurePortableContextScaffold(cwd, configToSave.name, configToSave.workflow);
+    upsertSourcePreparationConfig(sourcePath, configToSave);
+    ensurePortableContextScaffold(sourcePath, configToSave.name, configToSave.method);
     p.outro(configToSave.checks.length > 0
-        ? "Saved dataset.\nNext:\n  interf test\n  interf compile"
-        : "Saved dataset.\nNext:\n  interf or interf init");
+        ? "Saved Preparation.\nNext:\n  interf compile\n  interf test"
+        : "Saved Preparation.\nNext:\n  interf or interf init");
 }
-export { formatWorkflowLabel, createWorkflowWizard, createCompiledWorkflowWizard, } from "./create-workflow-wizard.js";
+export { formatMethodLabel, createMethodWizard, createCompiledMethodWizard, } from "./create-method-wizard.js";

package/dist/cli/commands/default.js

@@ -6,7 +6,7 @@ function printStaticLanding() {
     console.log();
     console.log(chalk.bold("  Interf"));
     console.log(chalk.dim("  Prepare data for agent work."));
-    console.log(chalk.dim("  Run locally, process files, show evidence that your data is ready, and write verifiable outputs as portable context for agents."));
+    console.log(chalk.dim("  Run locally, process files, show evidence that your data is ready, and write verifiable outputs as Portable Context for agents."));
     console.log();
     if (config) {
         console.log(chalk.dim(`  Agent: ${config.agent}`));
@@ -14,13 +14,14 @@ function printStaticLanding() {
     }
     console.log(chalk.dim("  Suggested flow:"));
     console.log(chalk.dim("    interf"));
-    console.log(chalk.dim("    interf test"));
+    console.log(chalk.dim("    interf web      # optional local UI/API"));
     console.log(chalk.dim("    interf compile"));
     console.log(chalk.dim("    interf test"));
+    console.log(chalk.dim("    interf test --target source-files   # optional baseline before compile"));
     console.log();
     console.log(chalk.dim("  More:"));
     console.log(chalk.dim("    interf init"));
-    console.log(chalk.dim("    interf create workflow"));
+    console.log(chalk.dim("    interf create method"));
     console.log(chalk.dim("    interf doctor --live"));
     console.log(chalk.dim("    interf --help"));
     console.log();

package/dist/cli/commands/doctor.js

@@ -11,7 +11,7 @@ function iconFor(status) {
 }
 export const doctorCommand = {
     command: "doctor",
-    describe: "Check local executor setup before a real local run",
+    describe: "Check local executor configuration before a real local run",
     builder: (yargs) => yargs
         .option("live", {
         type: "boolean",
@@ -30,7 +30,7 @@ export const doctorCommand = {
         if (config) {
             checks.push({
                 id: "config",
-                label: "Interf setup",
+                label: "Interf config",
                 status: "pass",
                 message: `Configured default agent: ${config.agent}`,
             });
@@ -38,9 +38,9 @@ export const doctorCommand = {
         else {
             checks.push({
                 id: "config",
-                label: "Interf setup",
+                label: "Interf config",
                 status: "warn",
-                message: "No saved Interf setup found. `interf` or `interf init` is recommended for deterministic local runs.",
+                message: "No saved Interf config found. `interf` or `interf init` is recommended for deterministic local runs.",
             });
         }
         if (!agent) {
@@ -97,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 check draft, workflow authoring run, test, or compile.",
+                message: "Skipped. Run `interf doctor --live` to exercise the real local agent before a check draft, Method authoring run, readiness check, or Compilation.",
             });
         }
         const ok = checks.every((check) => check.status !== "fail");

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

@@ -1,4 +1,4 @@
-import { type WorkflowExecutionProfile, type WorkflowExecutor } from "../../packages/agents/index.js";
+import { type MethodExecutionProfile, type MethodExecutor } from "../../packages/agents/index.js";
 export interface RunAgentOption {
     name: string;
     displayName: string;
@@ -9,9 +9,9 @@ export declare function resolvedConfiguredAgentName(): string | null;
 export declare function listRunAgentOptions(): RunAgentOption[];
 export declare function resolveNamedLocalExecutor(agentName: string, options?: {
     preflight?: boolean;
-    executionProfile?: WorkflowExecutionProfile;
+    executionProfile?: MethodExecutionProfile;
 }): {
-    executor: WorkflowExecutor | null;
+    executor: MethodExecutor | null;
     error?: string;
 };
 export declare function promptForTestAgents(): Promise<{
@@ -20,10 +20,10 @@ export declare function promptForTestAgents(): Promise<{
 }>;
 export declare function resolveOrConfigureLocalExecutor(options?: {
     preflight?: boolean;
-    executionProfile?: WorkflowExecutionProfile;
-    purpose?: "compile" | "test" | "draft" | "workflow";
+    executionProfile?: MethodExecutionProfile;
+    purpose?: "compile" | "test" | "draft" | "method";
 }): Promise<{
-    executor: WorkflowExecutor | null;
+    executor: MethodExecutor | null;
     error?: string;
     cancelled?: boolean;
 }>;

package/dist/cli/commands/executor-flow.js

@@ -87,8 +87,8 @@ export async function promptForTestAgents() {
 async function promptForRunAgent(purpose) {
     const purposeLabel = purpose === "draft"
         ? "check draft"
-        : purpose === "workflow"
-            ? "workflow authoring"
+        : purpose === "method"
+            ? "Method authoring"
             : purpose;
     const detected = supportedDetectedAgents();
     if (detected.length === 0)

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

@@ -1,10 +1,10 @@
 import type { CommandModule } from "yargs";
-import type { SourceDatasetConfig } from "../../packages/project-model/lib/schema.js";
+import type { SourcePreparationConfig } 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?: {
+export declare function compileSelectedCompiled(sourcePath: string, compiledConfig: SourcePreparationConfig, deps?: {
     runCompileCommand?: typeof runCompileCommand;
 }): Promise<import("./compile.js").CompileCommandResult | null>;
 export declare const initCommand: CommandModule;