@interf/compiler 0.7.3 → 0.9.1

package/dist/cli/commands/create.js

@@ -6,16 +6,16 @@ import { SOURCE_FOLDER_CONFIG_PATH, listSourceDatasetConfigs, loadSourceFolderCo
 import { chooseOrCreateCompiledWorkflowForDataset, createWorkflowWizard, } from "./create-workflow-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 { resolveCommandControlPath, resolveInterfInstanceContext, } from "./control-path.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,14 +25,14 @@ 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",
             },
         ],
     });
@@ -41,27 +41,27 @@ 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.`);
+        p.log.info(`Created Method "${workflowId}".`);
+        p.log.info(`Next: run \`interf\`, add a Preparation, then assign Method "${workflowId}" 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 "${workflowId}".`);
+        p.log.info(`Next: run \`interf\`, open a saved Preparation, and assign Method "${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?",
+            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} question${dataset.checks.length === 1 ? "" : "s"}`}`,
+                hint: `${dataset.path} · ${dataset.about ?? `${dataset.checks.length} readiness check${dataset.checks.length === 1 ? "" : "s"}`}`,
             })),
         });
         if (p.isCancel(selected))
@@ -72,6 +72,7 @@ async function maybeAssignWorkflowToDataset(sourcePath, workflowId) {
         return;
     const nextConfig = {
         ...targetDataset,
+        method: workflowId,
         workflow: workflowId,
     };
     upsertSourceDatasetConfig(sourcePath, nextConfig, {
@@ -84,18 +85,18 @@ async function maybeAssignWorkflowToDataset(sourcePath, workflowId) {
     else {
         ensurePortableContextScaffold(sourcePath, nextConfig.name, nextConfig.workflow ?? "interf-default");
     }
-    p.log.info(`Assigned workflow "${workflowId}" to dataset "${targetDataset.name}".`);
+    p.log.info(`Assigned Method "${workflowId}" to Preparation "${targetDataset.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 sourcePath = detected ? resolveSourceControlPath(detected.path) : resolveCommandControlPath();
             const workflowId = await createWorkflowWizard({
-                sourcePath: detected ? resolveSourceControlPath(detected.path) : process.cwd(),
+                sourcePath,
                 executionProfile,
             });
             if (typeof workflowId === "string") {
-                await maybeAssignWorkflowToDataset(detected ? resolveSourceControlPath(detected.path) : process.cwd(), workflowId);
+                await maybeAssignWorkflowToDataset(sourcePath, workflowId);
             }
             return;
         }
@@ -129,24 +131,35 @@ 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));
+    const initContext = resolveInterfInstanceContext(cwd);
+    const sourcePath = initContext.controlPath;
+    const savedDatasets = listSourceDatasetConfigs(loadSourceFolderConfig(sourcePath));
     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.`);
+        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.`);
     }
-    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: defaultDatasetNameForPath(initContext.defaultSourceFolderPath),
+            path: initContext.defaultPreparationPath,
+        }
+        : { name: DEFAULT_COMPILED_NAME };
     const draft = await promptSingleCompiledConfig({
-        projectPath: cwd,
-        initial: { name: DEFAULT_COMPILED_NAME },
+        projectPath: sourcePath,
+        initial: initialConfig,
         introStyle: existingConfig ? "additional" : "first",
     });
     if (!draft)
@@ -154,10 +167,10 @@ export async function createCompiledWizard(options = {}) {
     const existingNames = new Set(listSourceDatasetConfigs(existingConfig).map((dataset) => dataset.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, {
+    const workflowChoice = await chooseOrCreateCompiledWorkflowForDataset(sourcePath, draft, {
         currentWorkflowId: "interf-default",
         executionProfile: options.executionProfile,
     });
@@ -165,12 +178,13 @@ export async function createCompiledWizard(options = {}) {
         return;
     const configToSave = {
         ...draft,
+        method: String(workflowChoice),
         workflow: String(workflowChoice),
     };
-    upsertSourceDatasetConfig(cwd, configToSave);
-    ensurePortableContextScaffold(cwd, configToSave.name, configToSave.workflow);
+    upsertSourceDatasetConfig(sourcePath, configToSave);
+    ensurePortableContextScaffold(sourcePath, configToSave.name, configToSave.workflow);
     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";

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 raw   # 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.js

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