@interf/compiler 0.9.1 → 0.9.4

package/dist/cli/commands/create.js

@@ -2,12 +2,13 @@ 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 { defaultDatasetNameForPath, } from "../../packages/project-model/source-folders.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;
@@ -37,12 +38,12 @@ async function selectCreateTarget() {
         ],
     });
 }
-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 Method "${workflowId}".`);
-        p.log.info(`Next: run \`interf\`, add a Preparation, then assign Method "${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({
@@ -50,42 +51,41 @@ async function maybeAssignWorkflowToDataset(sourcePath, workflowId) {
         initialValue: true,
     });
     if (p.isCancel(assignNow) || !assignNow) {
-        p.log.info(`Created Method "${workflowId}".`);
-        p.log.info(`Next: run \`interf\`, open a saved Preparation, and assign Method "${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 saved Preparation should use this Method?",
-            options: datasets.map((dataset) => ({
-                value: dataset.name,
-                label: dataset.name,
-                hint: `${dataset.path} · ${dataset.about ?? `${dataset.checks.length} readiness check${dataset.checks.length === 1 ? "" : "s"}`}`,
+            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,
-        method: workflowId,
-        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 Method "${workflowId}" to Preparation "${targetDataset.name}".`);
+    p.log.info(`Assigned Method "${methodId}" to Preparation "${targetPreparation.name}".`);
     if (builtCompiledPath) {
         p.log.info("The active local Method copy for that Portable Context lives under `.interf/method/`.");
     }
@@ -117,12 +117,12 @@ export const createCommand = {
         if (type === "method") {
             const detected = detectInterf(process.cwd());
             const sourcePath = detected ? resolveSourceControlPath(detected.path) : resolveCommandControlPath();
-            const workflowId = await createWorkflowWizard({
+            const methodId = await createMethodWizard({
                 sourcePath,
                 executionProfile,
             });
-            if (typeof workflowId === "string") {
-                await maybeAssignWorkflowToDataset(sourcePath, workflowId);
+            if (typeof methodId === "string") {
+                await maybeAssignMethodToPreparation(sourcePath, methodId);
             }
             return;
         }
@@ -142,9 +142,9 @@ export async function createCompiledWizard(options = {}) {
     }
     const initContext = resolveInterfInstanceContext(cwd);
     const sourcePath = initContext.controlPath;
-    const savedDatasets = listSourceDatasetConfigs(loadSourceFolderConfig(sourcePath));
-    if (savedDatasets.length > 0) {
-        p.log.info(`This Source Folder already has ${savedDatasets.length} saved Preparation${savedDatasets.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.`);
+    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.`);
     }
     if (sourcePath !== cwd) {
         p.log.info(`Interf Workspace: ${sourcePath}`);
@@ -153,10 +153,10 @@ export async function createCompiledWizard(options = {}) {
     const existingConfig = loadSourceFolderConfig(sourcePath);
     const initialConfig = initContext.defaultSourceFolderPath && initContext.defaultPreparationPath
         ? {
-            name: defaultDatasetNameForPath(initContext.defaultSourceFolderPath),
+            name: defaultPreparationNameForPath(initContext.defaultSourceFolderPath),
             path: initContext.defaultPreparationPath,
         }
-        : { name: DEFAULT_COMPILED_NAME };
+        : { name: DEFAULT_PREPARATION_NAME };
     const draft = await promptSingleCompiledConfig({
         projectPath: sourcePath,
         initial: initialConfig,
@@ -164,27 +164,26 @@ export async function createCompiledWizard(options = {}) {
     });
     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(`Preparation "${draft.name}" already exists. Use \`interf\` or \`interf init\` to edit it.`);
         return;
     }
-    const workflowChoice = await chooseOrCreateCompiledWorkflowForDataset(sourcePath, 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,
-        method: String(workflowChoice),
-        workflow: String(workflowChoice),
+        method: String(methodChoice),
     };
-    upsertSourceDatasetConfig(sourcePath, configToSave);
-    ensurePortableContextScaffold(sourcePath, configToSave.name, configToSave.workflow);
+    upsertSourcePreparationConfig(sourcePath, configToSave);
+    ensurePortableContextScaffold(sourcePath, configToSave.name, configToSave.method);
     p.outro(configToSave.checks.length > 0
         ? "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

@@ -17,7 +17,7 @@ function printStaticLanding() {
     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 raw   # optional baseline before compile"));
+    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"));

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,7 +87,7 @@ export async function promptForTestAgents() {
 async function promptForRunAgent(purpose) {
     const purposeLabel = purpose === "draft"
         ? "check draft"
-        : purpose === "workflow"
+        : purpose === "method"
             ? "Method authoring"
             : purpose;
     const detected = supportedDetectedAgents();

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;