@interf/compiler 0.5.0 → 0.6.1

package/dist/commands/create-workflow-wizard.js

@@ -1,8 +1,13 @@
 import chalk from "chalk";
 import * as p from "@clack/prompts";
-import { listCompiledWorkflowChoices, } from "../lib/workflow-definitions.js";
+import { statSync } from "node:fs";
+import { resolve } from "node:path";
+import { listCompiledWorkflowChoices, getCompiledWorkflow, } from "../lib/workflow-definitions.js";
 import { createLocalWorkflowPackageFromTemplate } from "../lib/interf-workflow-package.js";
 import { isWorkflowId, } from "../lib/local-workflows.js";
+import { resolveOrConfigureLocalExecutor } from "./executor-flow.js";
+import { runWorkflowAuthoringDraft } from "../lib/workflow-authoring.js";
+import { listSourceDatasetConfigs, loadSourceFolderConfig, resolveSourceDatasetPath, } from "../lib/source-config.js";
 import { slugify } from "../lib/util.js";
 export const clackWorkflowPrompts = {
     intro: p.intro,
@@ -11,8 +16,22 @@ export const clackWorkflowPrompts = {
     isCancel: p.isCancel,
     log: {
         info: p.log.info,
+        error: p.log.error,
     },
 };
+function findMatchingDatasetConfig(sourcePath, datasetPath) {
+    const config = loadSourceFolderConfig(sourcePath);
+    for (const dataset of listSourceDatasetConfigs(config)) {
+        if (resolveSourceDatasetPath(sourcePath, dataset) === datasetPath) {
+            return dataset;
+        }
+    }
+    return null;
+}
+function describeSavedDataset(dataset) {
+    return dataset.about
+        ?? `${dataset.checks.length} saved truth check${dataset.checks.length === 1 ? "" : "s"} · path ${dataset.path}`;
+}
 export function formatWorkflowLabel(workflow) {
     return {
         value: workflow.id,
@@ -54,15 +73,38 @@ export async function createWorkflowWizard(options = {}, prompts = clackWorkflow
         prompts.intro(chalk.bold("Create a workflow"));
     }
     const sourcePath = options.sourcePath ?? process.cwd();
-    return createCompiledWorkflowWizard(sourcePath, prompts);
+    return createCompiledWorkflowWizard(sourcePath, prompts, {
+        executionProfile: options.executionProfile,
+        datasetContext: options.datasetContext,
+        resolveExecutor: options.resolveExecutor,
+        runDraft: options.runDraft,
+    });
 }
-export async function createCompiledWorkflowWizard(sourcePath, prompts = clackWorkflowPrompts) {
+export async function createCompiledWorkflowWizard(sourcePath, prompts = clackWorkflowPrompts, options = {}) {
     const baseWorkflow = await prompts.select({
         message: "Start from which existing workflow?",
         options: listCompiledWorkflowChoices(sourcePath).map(formatWorkflowLabel),
     });
     if (prompts.isCancel(baseWorkflow))
         return baseWorkflow;
+    const resolvedBaseWorkflow = getCompiledWorkflow(String(baseWorkflow), { sourcePath });
+    const creationMode = await prompts.select({
+        message: "How do you want to create it?",
+        options: [
+            {
+                value: "draft",
+                label: "Draft a workflow from this dataset (Recommended)",
+                hint: "Seed a workflow, prepare a preview, then let a local agent draft a reusable method for this task",
+            },
+            {
+                value: "manual",
+                label: "Copy an existing workflow",
+                hint: "Start from an existing workflow and edit stage guidance directly",
+            },
+        ],
+    });
+    if (prompts.isCancel(creationMode))
+        return creationMode;
     const rawName = await prompts.text({
         message: "New workflow name?",
         placeholder: "founder-research",
@@ -89,36 +131,130 @@ export async function createCompiledWorkflowWizard(sourcePath, prompts = clackWo
     });
     if (prompts.isCancel(hint))
         return hint;
-    const summarizeBias = await prompts.text({
-        message: "What should summarize emphasize?",
-        placeholder: "Preserve evidence tiers, decision context, and source metadata",
-        validate: (value) => (value.trim().length === 0 ? "Summarize guidance is required" : undefined),
-    });
-    if (prompts.isCancel(summarizeBias))
-        return summarizeBias;
-    const structureBias = await prompts.text({
-        message: "What should structure emphasize?",
-        placeholder: "Build retrieval-ready entities, claims, timelines, and indexes",
-        validate: (value) => (value.trim().length === 0 ? "Structure guidance is required" : undefined),
-    });
-    if (prompts.isCancel(structureBias))
-        return structureBias;
-    const shapeBias = await prompts.text({
-        message: "What should shape emphasize?",
-        placeholder: "Bias home.md and navigation toward the questions this dataset should answer best",
-        validate: (value) => (value.trim().length === 0 ? "Shape guidance is required" : undefined),
-    });
-    if (prompts.isCancel(shapeBias))
-        return shapeBias;
+    if (creationMode === "draft") {
+        let datasetPath = options.datasetContext?.datasetPath ?? null;
+        let matchedDataset = options.datasetContext?.config ?? null;
+        if (!datasetPath) {
+            const savedDatasets = listSourceDatasetConfigs(loadSourceFolderConfig(sourcePath));
+            if (savedDatasets.length > 0) {
+                const datasetChoice = await prompts.select({
+                    message: "Which dataset should shape this workflow?",
+                    options: [
+                        ...savedDatasets.map((dataset) => ({
+                            value: dataset.name,
+                            label: dataset.name,
+                            hint: describeSavedDataset(dataset),
+                        })),
+                        {
+                            value: "__manual__",
+                            label: "Enter folder path manually",
+                            hint: "Use a folder that is not saved as a dataset yet",
+                        },
+                    ],
+                });
+                if (prompts.isCancel(datasetChoice))
+                    return datasetChoice;
+                if (datasetChoice !== "__manual__") {
+                    matchedDataset = savedDatasets.find((dataset) => dataset.name === datasetChoice) ?? null;
+                    datasetPath = matchedDataset
+                        ? resolveSourceDatasetPath(sourcePath, matchedDataset)
+                        : null;
+                }
+            }
+        }
+        if (!datasetPath) {
+            const datasetFolder = await prompts.text({
+                message: "Which dataset folder should shape this workflow?",
+                placeholder: ".",
+                initialValue: ".",
+                validate: (value) => {
+                    const trimmed = value.trim();
+                    if (trimmed.length === 0)
+                        return "Dataset folder is required";
+                    const absolutePath = resolve(sourcePath, trimmed);
+                    try {
+                        const stat = statSync(absolutePath);
+                        return stat.isDirectory() ? undefined : "Dataset folder must be a directory";
+                    }
+                    catch {
+                        return "Dataset folder was not found";
+                    }
+                },
+            });
+            if (prompts.isCancel(datasetFolder))
+                return datasetFolder;
+            datasetPath = resolve(sourcePath, String(datasetFolder).trim());
+            matchedDataset = matchedDataset ?? findMatchingDatasetConfig(sourcePath, datasetPath);
+        }
+        const taskPrompt = await prompts.text({
+            message: "What task should this workflow prepare the dataset for?",
+            placeholder: "Example: chart reads, board-prep questions, or latest planned launch status",
+            validate: (value) => (value.trim().length === 0 ? "Task focus is required" : undefined),
+        });
+        if (prompts.isCancel(taskPrompt))
+            return taskPrompt;
+        if (matchedDataset) {
+            prompts.log.info(`Shaping this workflow from dataset "${matchedDataset.name}".`);
+        }
+        if (matchedDataset?.checks.length) {
+            prompts.log.info(`Using ${matchedDataset.checks.length} saved truth check${matchedDataset.checks.length === 1 ? "" : "s"} from dataset "${matchedDataset.name}" as authoring context.`);
+        }
+        const resolveExecutor = options.resolveExecutor ?? resolveOrConfigureLocalExecutor;
+        const runDraft = options.runDraft ?? runWorkflowAuthoringDraft;
+        const { executor, error } = await resolveExecutor({
+            executionProfile: options.executionProfile,
+            purpose: "workflow",
+        });
+        if (!executor && !error) {
+            return null;
+        }
+        if (!executor) {
+            process.exitCode = 1;
+            (prompts.log.error ?? prompts.log.info)(error ?? "No coding agent detected.");
+            return null;
+        }
+        prompts.log.info("Preparing a workflow-authoring preview from the dataset, then drafting the package.");
+        const result = await runDraft({
+            sourcePath,
+            datasetPath,
+            baseWorkflowId: baseWorkflow,
+            workflowId,
+            label,
+            hint: hint.trim(),
+            taskPrompt: taskPrompt.trim(),
+            checks: matchedDataset?.checks ?? [],
+            executor,
+            preparePreview: true,
+        });
+        if (result.status === "updated") {
+            prompts.log.info(`Saved local workflow: ${result.workflowPath}`);
+            return workflowId;
+        }
+        process.exitCode = 1;
+        (prompts.log.error ?? prompts.log.info)(result.status === "no-change"
+            ? `${result.summary} Draft mode only succeeds when it produces a task-specific package change.`
+            : result.summary);
+        prompts.log.info(`Workflow shell kept at: ${result.shellPath}`);
+        return null;
+    }
+    const stagePolicyNotes = {};
+    for (const stage of resolvedBaseWorkflow.stages) {
+        const stagePrompt = await prompts.text({
+            message: `What should ${stage.id} (${stage.label}) emphasize?`,
+            placeholder: stage.description,
+            validate: (value) => (value.trim().length === 0 ? `${stage.label} guidance is required` : undefined),
+        });
+        if (prompts.isCancel(stagePrompt))
+            return stagePrompt;
+        stagePolicyNotes[stage.id] = [String(stagePrompt).trim()];
+    }
     const workflowPath = createLocalWorkflowPackageFromTemplate({
         sourcePath,
         baseWorkflowId: baseWorkflow,
         workflowId,
         label,
         hint: hint.trim(),
-        summarizeBias: summarizeBias.trim(),
-        structureBias: structureBias.trim(),
-        shapeBias: shapeBias.trim(),
+        stagePolicyNotes,
     });
     prompts.log.info(`Saved local workflow: ${workflowPath}`);
     return workflowId;

package/dist/commands/create.d.ts

@@ -5,4 +5,4 @@ export declare function createCompiledWizard(options?: {
     intro?: boolean;
     executionProfile?: WorkflowExecutionProfile;
 }): Promise<void>;
-export { type WorkflowWizardPrompts, formatWorkflowLabel, chooseCompiledWorkflow, createWorkflowWizard, createCompiledWorkflowWizard, } from "./create-workflow-wizard.js";
+export { type WorkflowWizardPrompts, formatWorkflowLabel, createWorkflowWizard, createCompiledWorkflowWizard, } from "./create-workflow-wizard.js";

package/dist/commands/create.js

@@ -1,15 +1,13 @@
 import chalk from "chalk";
 import { basename } from "node:path";
 import * as p from "@clack/prompts";
-import { detectInterf, defaultCompiledNameForSource, listCompiledDatasetsForSourceFolder, } from "../lib/interf.js";
+import { detectInterf, defaultCompiledNameForSource, listCompiledDatasetsForSourceFolder, resolveSourceControlPath, } from "../lib/interf.js";
 import { slugify } from "../lib/util.js";
 import { addExecutionProfileOptions, executionProfileFromArgv, } from "../lib/execution-profile.js";
-import { listSourceDatasetConfigs, loadSourceFolderConfig, upsertSourceDatasetConfig, } from "../lib/source-config.js";
+import { listSourceDatasetConfigs, loadSourceFolderConfig, syncCompiledInterfConfigFromSourceDatasetConfig, upsertSourceDatasetConfig, } from "../lib/source-config.js";
 import { createWorkflowWizard, } from "./create-workflow-wizard.js";
-import { ensureCompiledFromConfig, } from "./compiled-flow.js";
+import { findBuiltCompiledPath, } from "./compiled-flow.js";
 import { DEFAULT_COMPILED_NAME, promptSingleCompiledConfig, } from "./source-config-wizard.js";
-import { resolveOrConfigureLocalExecutor } from "./executor-flow.js";
-import { runConfiguredCompiledCompile } from "./compile.js";
 function normalizeCreateTarget(value) {
     if (!value)
         return null;
@@ -41,6 +39,56 @@ async function selectCreateTarget() {
         ],
     });
 }
+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 dataset, then assign workflow "${workflowId}" from that dataset 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 dataset, and assign workflow "${workflowId}" from that dataset menu.`);
+        return;
+    }
+    let targetDataset = datasets[0] ?? null;
+    if (datasets.length > 1) {
+        const selected = await p.select({
+            message: "Which dataset should use this workflow?",
+            options: datasets.map((dataset) => ({
+                value: dataset.name,
+                label: dataset.name,
+                hint: `${dataset.path} · ${dataset.about ?? `${dataset.checks.length} saved truth 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 built dataset 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",
@@ -65,7 +113,14 @@ export const createCommand = {
             type = selected;
         }
         if (type === "workflow") {
-            await createWorkflowWizard({ sourcePath: process.cwd() });
+            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 });
@@ -86,10 +141,9 @@ export async function createCompiledWizard(options = {}) {
     if (existing.length > 0) {
         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 measures one dataset at a time. Start with truth checks and a baseline, then build a compiled dataset only when you need it.");
+    p.log.info("Interf works one dataset at a time. Start with the task, truth checks, and a baseline, then build a compiled dataset only when you need it.");
     const existingConfig = loadSourceFolderConfig(cwd);
     const suggestedName = slugify(defaultCompiledNameForSource(cwd) || basename(cwd)) || DEFAULT_COMPILED_NAME;
-    const workflowId = "interf";
     const draft = await promptSingleCompiledConfig({
         projectPath: cwd,
         initial: { name: suggestedName },
@@ -99,7 +153,7 @@ export async function createCompiledWizard(options = {}) {
         return;
     const configToSave = {
         ...draft,
-        workflow: workflowId,
+        workflow: "interf",
     };
     const existingNames = new Set(listSourceDatasetConfigs(existingConfig).map((dataset) => dataset.name));
     if (existingNames.has(configToSave.name)) {
@@ -108,55 +162,8 @@ export async function createCompiledWizard(options = {}) {
         return;
     }
     upsertSourceDatasetConfig(cwd, configToSave);
-    const compileNow = await p.confirm({
-        message: "Build the compiled dataset now? (Recommended)",
-        initialValue: true,
-    });
-    if (p.isCancel(compileNow) || !compileNow) {
-        p.outro(configToSave.checks.length > 0
-            ? "Next:\n  interf test\n  interf compile"
-            : "Next:\n  interf or interf init");
-        return;
-    }
-    const { executor, error } = await resolveOrConfigureLocalExecutor({
-        executionProfile: options.executionProfile,
-        purpose: "compile",
-    });
-    if (!executor && !error) {
-        return;
-    }
-    if (!executor) {
-        process.exitCode = 1;
-        p.log.error(error ?? "No coding agent detected.");
-        return;
-    }
-    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 compileCompiledAfterCreate(executor, sourcePath, datasetConfig, compiledPath, executionProfile) {
-    const compiled = await runConfiguredCompiledCompile({
-        executor,
-        compiledPath,
-        sourcePath,
-        compiledConfig: datasetConfig,
-        executionProfile,
-        maxAttemptsOverride: null,
-        maxLoopsOverride: null,
-    });
-    if (!compiled)
-        process.exitCode = 1;
-    return compiled;
+    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, chooseCompiledWorkflow, createWorkflowWizard, createCompiledWorkflowWizard, } from "./create-workflow-wizard.js";
+export { formatWorkflowLabel, createWorkflowWizard, createCompiledWorkflowWizard, } from "./create-workflow-wizard.js";

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

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

package/dist/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/default.js

@@ -4,8 +4,8 @@ import { runInitCommand } from "./init.js";
 function printStaticLanding() {
     const config = 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("  Define the task, save truth checks, measure raw files first, then compile only if they are not good enough."));
     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/doctor.js

@@ -12,7 +12,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",
@@ -31,7 +31,7 @@ export const doctorCommand = {
         if (config) {
             checks.push({
                 id: "config",
-                label: "Interf Compiler setup",
+                label: "Interf setup",
                 status: "pass",
                 message: `Configured default agent: ${config.agent}`,
             });
@@ -39,9 +39,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 +56,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}`);
@@ -79,7 +79,7 @@ export const doctorCommand = {
                 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 +98,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 truth-check draft, workflow authoring run, test, or compile.",
             });
         }
         const ok = checks.every((check) => check.status !== "fail");
@@ -115,7 +115,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/executor-flow.d.ts

@@ -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/executor-flow.js

@@ -25,7 +25,6 @@ function persistSelectedAgent(selectedName) {
         agent: selected.name,
         agentCommand: selected.command,
         skillsInstalled: current?.skillsInstalled ?? false,
-        ...(current?.viewer ? { viewer: current.viewer } : {}),
         initialized: current?.initialized ?? new Date().toISOString(),
     });
 }
@@ -89,7 +88,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"
+        ? "truth-check draft"
+        : purpose === "workflow"
+            ? "workflow authoring"
+            : purpose;
     const detected = supportedDetectedAgents();
     if (detected.length === 0)
         return { selected: false, cancelled: false };

package/dist/commands/init.d.ts

@@ -1,3 +1,8 @@
 import type { CommandModule } from "yargs";
+import type { SourceDatasetConfig } from "../lib/schema.js";
+import { runCompileCommand } from "./compile.js";
+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>;