@interf/compiler 0.1.8

package/dist/commands/create.js

@@ -0,0 +1,813 @@
+import chalk from "chalk";
+import { basename } from "node:path";
+import * as p from "@clack/prompts";
+import { detectInterf, listKnowledgeBasesForSourceFolder, readInterfConfig, resolveInterfaceKnowledgeBasePath, resolveKnowledgeBaseSourcePath, writeInterfaceCompilePlanTemplate, } from "../lib/interf.js";
+import { discoverSourceFiles } from "../lib/discovery.js";
+import { addKnowledgeBaseWithWorkflow, addInterface } from "../lib/registry.js";
+import { resolveLocalExecutor } from "../lib/executors.js";
+import { loadRegistry } from "../lib/registry.js";
+import { loadUserConfig } from "../lib/user-config.js";
+import { formatInterfaceWorkflowStageStep, formatKnowledgeBaseWorkflowStageStep, listInterfaceWorkflowChoices, listKnowledgeBaseInterfaceWorkflowChoices, listKnowledgeBaseWorkflowChoices, resolveInterfaceWorkflowFromConfig, resolveKnowledgeBaseWorkflowFromConfig, } from "../lib/workflow-definitions.js";
+import { createKnowledgeBase, createInterface, planInterface, compileKnowledgeBase as compileKnowledgeBaseWorkflow, compileInterface as compileInterfaceWorkflow, } from "../lib/workflows.js";
+import { isWorkflowId, writeLocalWorkflowDefinition, } from "../lib/local-workflows.js";
+import { renderJsonFrontmatter } from "../lib/parse.js";
+const clackWorkflowPrompts = {
+    intro: p.intro,
+    select: (options) => p.select(options),
+    text: (options) => p.text(options),
+    isCancel: p.isCancel,
+    log: {
+        info: p.log.info,
+    },
+};
+function slugify(input) {
+    return input
+        .toLowerCase()
+        .trim()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 80);
+}
+function normalizeCreateTarget(value) {
+    if (!value)
+        return null;
+    switch (value) {
+        case "knowledge-base":
+        case "knowledgebase":
+        case "base":
+        case "kb":
+            return "knowledge-base";
+        case "interface":
+            return "interface";
+        case "workflow":
+        case "wf":
+            return "workflow";
+        default:
+            return null;
+    }
+}
+async function selectCreateTarget() {
+    const detected = detectInterf(process.cwd());
+    const registry = loadRegistry();
+    if (!detected && registry.knowledgeBases.length === 0) {
+        return "knowledge-base";
+    }
+    const recommendInterface = Boolean(detected);
+    return p.select({
+        message: "Create what?",
+        options: recommendInterface
+            ? [
+                {
+                    value: "interface",
+                    label: "Interface (Recommended)",
+                    hint: "Create a focused workspace on top of an existing knowledge base",
+                },
+                {
+                    value: "knowledge-base",
+                    label: "Knowledge Base",
+                    hint: "Attach the current folder as a new local knowledge base",
+                },
+                {
+                    value: "workflow",
+                    label: "Workflow",
+                    hint: "Create a reusable workflow package for knowledge bases or interfaces",
+                },
+            ]
+            : [
+                {
+                    value: "knowledge-base",
+                    label: "Knowledge Base (Recommended)",
+                    hint: "Attach the current folder as a new local knowledge base",
+                },
+                {
+                    value: "interface",
+                    label: "Interface",
+                    hint: "Create an interface from a knowledge base already in your registry",
+                },
+                {
+                    value: "workflow",
+                    label: "Workflow",
+                    hint: "Create a reusable workflow package for knowledge bases or interfaces",
+                },
+            ],
+    });
+}
+async function selectWorkflowTargetType(prompts = clackWorkflowPrompts) {
+    return prompts.select({
+        message: "Workflow type?",
+        options: [
+            {
+                value: "knowledge-base",
+                label: "Knowledge Base Workflow (Recommended)",
+                hint: "Create a reusable compile method for attached folders",
+            },
+            {
+                value: "interface",
+                label: "Interface Workflow",
+                hint: "Create a reusable task-specific method on top of a knowledge base",
+            },
+        ],
+    });
+}
+function formatWorkflowLabel(workflow) {
+    return {
+        value: workflow.id,
+        label: workflow.scope === "local" ? `${workflow.label} (Local)` : workflow.label,
+        hint: workflow.hint,
+    };
+}
+const CREATE_NEW_WORKFLOW_VALUE = "__create_new_workflow__";
+export function buildKnowledgeBaseWorkflowOptions(sourcePath) {
+    return [
+        ...listKnowledgeBaseWorkflowChoices(sourcePath).map(formatWorkflowLabel),
+        {
+            value: CREATE_NEW_WORKFLOW_VALUE,
+            label: "Create new workflow...",
+            hint: "Answer a few questions and save a reusable local workflow under interf/workflows/",
+        },
+    ];
+}
+export function buildInterfaceWorkflowOptions(knowledgeBasePath) {
+    const sourcePath = resolveKnowledgeBaseSourcePath(knowledgeBasePath);
+    const workflowMap = new Map();
+    for (const workflow of listKnowledgeBaseInterfaceWorkflowChoices(knowledgeBasePath)) {
+        workflowMap.set(workflow.id, workflow);
+    }
+    for (const workflow of listInterfaceWorkflowChoices(sourcePath)) {
+        if (!workflowMap.has(workflow.id))
+            workflowMap.set(workflow.id, workflow);
+    }
+    return [
+        ...Array.from(workflowMap.values()).map(formatWorkflowLabel),
+        {
+            value: CREATE_NEW_WORKFLOW_VALUE,
+            label: "Create new interface workflow...",
+            hint: "Answer a few questions and save a reusable interface workflow template",
+        },
+    ];
+}
+function buildStandaloneInterfaceWorkflowOptions(sourcePath) {
+    return [
+        ...listInterfaceWorkflowChoices(sourcePath).map(formatWorkflowLabel),
+        {
+            value: CREATE_NEW_WORKFLOW_VALUE,
+            label: "Create new interface workflow...",
+            hint: "Answer a few questions and save a reusable interface workflow template",
+        },
+    ];
+}
+async function chooseKnowledgeBaseWorkflow(sourcePath) {
+    const workflowChoice = await p.select({
+        message: "Knowledge-base workflow?",
+        options: buildKnowledgeBaseWorkflowOptions(sourcePath),
+    });
+    if (p.isCancel(workflowChoice))
+        return workflowChoice;
+    if (workflowChoice === CREATE_NEW_WORKFLOW_VALUE) {
+        return createKnowledgeBaseWorkflowWizard(sourcePath);
+    }
+    return workflowChoice;
+}
+async function chooseInterfaceWorkflow(knowledgeBasePath) {
+    const workflowChoice = await p.select({
+        message: "Interface workflow?",
+        options: buildInterfaceWorkflowOptions(knowledgeBasePath),
+    });
+    if (p.isCancel(workflowChoice))
+        return workflowChoice;
+    if (workflowChoice === CREATE_NEW_WORKFLOW_VALUE) {
+        return createInterfaceWorkflowWizard({
+            sourcePath: resolveKnowledgeBaseSourcePath(knowledgeBasePath),
+            knowledgeBasePath,
+        });
+    }
+    return workflowChoice;
+}
+async function createWorkflowWizard(options = {}, prompts = clackWorkflowPrompts) {
+    if (options.intro !== false) {
+        prompts.intro(chalk.bold("Create a workflow"));
+    }
+    const workflowType = options.type ?? await selectWorkflowTargetType(prompts);
+    if (prompts.isCancel(workflowType))
+        return workflowType;
+    const sourcePath = options.sourcePath ?? process.cwd();
+    if (workflowType === "knowledge-base") {
+        return createKnowledgeBaseWorkflowWizard(sourcePath, prompts);
+    }
+    return createInterfaceWorkflowWizard({
+        sourcePath,
+        knowledgeBasePath: options.knowledgeBasePath,
+    }, prompts);
+}
+export async function createKnowledgeBaseWorkflowWizard(sourcePath, prompts = clackWorkflowPrompts) {
+    const baseWorkflow = await prompts.select({
+        message: "Start from which existing knowledge-base workflow?",
+        options: listKnowledgeBaseWorkflowChoices(sourcePath).map(formatWorkflowLabel),
+    });
+    if (prompts.isCancel(baseWorkflow))
+        return baseWorkflow;
+    const rawName = await prompts.text({
+        message: "New workflow name?",
+        placeholder: "founder-research",
+        validate: (value) => {
+            if (value.trim().length === 0)
+                return "Name is required";
+            const workflowId = slugify(value);
+            if (!isWorkflowId(workflowId))
+                return "Use letters, numbers, and dashes only";
+            if (listKnowledgeBaseWorkflowChoices(sourcePath).some((workflow) => workflow.id === workflowId)) {
+                return "That workflow name already exists";
+            }
+            return undefined;
+        },
+    });
+    if (prompts.isCancel(rawName))
+        return rawName;
+    const workflowId = slugify(rawName);
+    const label = rawName.trim();
+    const hint = await prompts.text({
+        message: "One-line workflow description?",
+        placeholder: "Bias toward investor-grade research and strong evidence tracking",
+        validate: (value) => (value.trim().length === 0 ? "Description is required" : undefined),
+    });
+    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 compileBias = await prompts.text({
+        message: "What should compile emphasize?",
+        placeholder: "Build retrieval-ready concepts, timelines, and decision indexes",
+        validate: (value) => (value.trim().length === 0 ? "Compile guidance is required" : undefined),
+    });
+    if (prompts.isCancel(compileBias))
+        return compileBias;
+    const workflowPath = writeLocalWorkflowDefinition(sourcePath, {
+        id: workflowId,
+        type: "knowledge-base",
+        label,
+        hint: hint.trim(),
+        extends: baseWorkflow,
+        stage_policy_notes: {
+            summarize: [summarizeBias.trim()],
+            compile: [compileBias.trim()],
+        },
+        starter_docs: [
+            {
+                relativePath: "README.md",
+                content: [
+                    renderJsonFrontmatter({ mode: "extend" }),
+                    `# ${label}`,
+                    "",
+                    `This local knowledge-base workflow extends \`${baseWorkflow}\`.`,
+                    "",
+                    `- summarize bias: ${summarizeBias.trim()}`,
+                    `- compile bias: ${compileBias.trim()}`,
+                    "",
+                ].join("\n"),
+            },
+        ],
+    });
+    prompts.log.info(`Saved local workflow: ${workflowPath}`);
+    return workflowId;
+}
+export async function createInterfaceWorkflowWizard(options, prompts = clackWorkflowPrompts) {
+    const sourcePath = options.sourcePath;
+    const knowledgeBasePath = options.knowledgeBasePath;
+    const workflowOptions = knowledgeBasePath
+        ? buildInterfaceWorkflowOptions(knowledgeBasePath)
+        : buildStandaloneInterfaceWorkflowOptions(sourcePath);
+    const baseWorkflow = await prompts.select({
+        message: "Start from which existing interface workflow?",
+        options: workflowOptions
+            .filter((option) => option.value !== CREATE_NEW_WORKFLOW_VALUE),
+    });
+    if (prompts.isCancel(baseWorkflow))
+        return baseWorkflow;
+    const rawName = await prompts.text({
+        message: "New workflow name?",
+        placeholder: "diligence-memo",
+        validate: (value) => {
+            if (value.trim().length === 0)
+                return "Name is required";
+            const workflowId = slugify(value);
+            if (!isWorkflowId(workflowId))
+                return "Use letters, numbers, and dashes only";
+            if (workflowOptions.some((workflow) => workflow.value === workflowId)) {
+                return "That workflow name already exists";
+            }
+            return undefined;
+        },
+    });
+    if (prompts.isCancel(rawName))
+        return rawName;
+    const workflowId = slugify(rawName);
+    const label = rawName.trim();
+    const hint = await prompts.text({
+        message: "One-line workflow description?",
+        placeholder: "Bias toward evidence-backed diligence notes and decision-ready outputs",
+        validate: (value) => (value.trim().length === 0 ? "Description is required" : undefined),
+    });
+    if (prompts.isCancel(hint))
+        return hint;
+    const placeholder = await prompts.text({
+        message: "Prompt placeholder for this interface workflow?",
+        placeholder: "What should this interface focus on for this knowledge base?",
+        validate: (value) => (value.trim().length === 0 ? "Placeholder is required" : undefined),
+    });
+    if (prompts.isCancel(placeholder))
+        return placeholder;
+    const retrieveBias = await prompts.text({
+        message: "What should retrieve emphasize?",
+        placeholder: "Current decisions, canonical docs, and materials with strong signal",
+        validate: (value) => (value.trim().length === 0 ? "Retrieve guidance is required" : undefined),
+    });
+    if (prompts.isCancel(retrieveBias))
+        return retrieveBias;
+    const analyzeBias = await prompts.text({
+        message: "What should analyze emphasize?",
+        placeholder: "Risks, contradictions, and evidence-weighted findings",
+        validate: (value) => (value.trim().length === 0 ? "Analyze guidance is required" : undefined),
+    });
+    if (prompts.isCancel(analyzeBias))
+        return analyzeBias;
+    const compileBias = await prompts.text({
+        message: "What should compile emphasize?",
+        placeholder: "Decision-ready notes, concise briefs, and linked evidence",
+        validate: (value) => (value.trim().length === 0 ? "Compile guidance is required" : undefined),
+    });
+    if (prompts.isCancel(compileBias))
+        return compileBias;
+    const workflowPath = writeLocalWorkflowDefinition(sourcePath, {
+        id: workflowId,
+        type: "interface",
+        label,
+        hint: hint.trim(),
+        extends: baseWorkflow,
+        placeholder: placeholder.trim(),
+        stage_policy_notes: {
+            retrieve: [retrieveBias.trim()],
+            analyze: [analyzeBias.trim()],
+            compile: [compileBias.trim()],
+        },
+        starter_docs: [
+            {
+                relativePath: "README.md",
+                content: [
+                    renderJsonFrontmatter({ mode: "extend" }),
+                    `# ${label}`,
+                    "",
+                    `This local interface workflow extends \`${baseWorkflow}\`.`,
+                    "",
+                    `- retrieve bias: ${retrieveBias.trim()}`,
+                    `- analyze bias: ${analyzeBias.trim()}`,
+                    `- compile bias: ${compileBias.trim()}`,
+                    "",
+                ].join("\n"),
+            },
+        ],
+    });
+    prompts.log.info(`Saved local workflow: ${workflowPath}`);
+    return workflowId;
+}
+export const createCommand = {
+    command: "create [type]",
+    describe: "Create a knowledge base, interface, or reusable workflow, or choose when omitted",
+    builder: (yargs) => yargs.positional("type", {
+        type: "string",
+        describe: "Type to create (`knowledge-base`, `interface`, or `workflow`)",
+        default: undefined,
+    }),
+    handler: async (argv) => {
+        const rawType = argv.type;
+        let type = normalizeCreateTarget(rawType);
+        if (rawType && !type) {
+            p.log.error(`Unknown create target: ${rawType}`);
+            return;
+        }
+        if (!type) {
+            const selected = await selectCreateTarget();
+            if (p.isCancel(selected))
+                return;
+            type = selected;
+        }
+        if (type === "knowledge-base") {
+            await createKnowledgeBaseWizard();
+            return;
+        }
+        if (type === "workflow") {
+            const cwd = process.cwd();
+            const detected = detectInterf(cwd);
+            let sourcePath = cwd;
+            let knowledgeBasePath;
+            if (detected?.config.type === "knowledge-base") {
+                knowledgeBasePath = detected.path;
+                sourcePath = resolveKnowledgeBaseSourcePath(detected.path);
+            }
+            else if (detected?.config.type === "interface") {
+                const parentKnowledgeBasePath = resolveInterfaceKnowledgeBasePath(detected.path);
+                if (parentKnowledgeBasePath) {
+                    knowledgeBasePath = parentKnowledgeBasePath;
+                    sourcePath = resolveKnowledgeBaseSourcePath(parentKnowledgeBasePath);
+                }
+            }
+            else {
+                const localKnowledgeBases = listKnowledgeBasesForSourceFolder(cwd);
+                if (localKnowledgeBases.length === 1) {
+                    knowledgeBasePath = localKnowledgeBases[0].path;
+                    sourcePath = resolveKnowledgeBaseSourcePath(localKnowledgeBases[0].path);
+                }
+            }
+            await createWorkflowWizard({ sourcePath, knowledgeBasePath });
+            return;
+        }
+        await createInterfaceWizard();
+    },
+};
+export async function createKnowledgeBaseWizard(options = {}) {
+    if (options.intro !== false) {
+        p.intro(chalk.bold("Create a knowledge base"));
+    }
+    p.log.info("Interf compiles this folder into an LLM knowledge base for agents.");
+    p.log.info("Your files stay on disk. Interf stores the compiled knowledge base under `./interf/<name>/` together with summaries, knowledge, agent instructions, and a local workflow package.");
+    const cwd = process.cwd();
+    const currentConfig = readInterfConfig(cwd);
+    if (currentConfig) {
+        p.log.error("You are already inside an Interf knowledge base or interface.");
+        return;
+    }
+    const existingKnowledgeBases = listKnowledgeBasesForSourceFolder(cwd);
+    if (existingKnowledgeBases.length > 0) {
+        p.log.info(`This source folder already has ${existingKnowledgeBases.length} knowledge base${existingKnowledgeBases.length === 1 ? "" : "s"}. Creating another is fine when you want to compare workflows on the same data.`);
+    }
+    const defaultName = slugify(basename(cwd));
+    const rawName = await p.text({
+        message: "Knowledge base name?",
+        placeholder: defaultName || "my-knowledge-base",
+        initialValue: defaultName,
+        validate: (v) => (v.length === 0 ? "Name is required" : undefined),
+    });
+    if (p.isCancel(rawName))
+        return;
+    const name = slugify(rawName);
+    if (name !== rawName) {
+        p.log.info(`Knowledge base name: ${name}`);
+    }
+    const workflowChoice = await chooseKnowledgeBaseWorkflow(cwd);
+    if (p.isCancel(workflowChoice))
+        return;
+    const selectedWorkflow = workflowChoice;
+    const s = p.spinner();
+    if (!options.skipSkillInstall) {
+        p.log.info("Interf uses bundled stage instructions and local workflow docs by default. Run `interf init` when you want to choose an executor or install optional global helper skills.");
+    }
+    // Create
+    s.start("Creating knowledge base...");
+    let knowledgeBasePath;
+    try {
+        knowledgeBasePath = createKnowledgeBase(name, cwd, selectedWorkflow);
+    }
+    catch (error) {
+        s.stop("Create failed");
+        p.log.error(error instanceof Error ? error.message : "Failed to create knowledge base.");
+        return;
+    }
+    addKnowledgeBaseWithWorkflow(name, knowledgeBasePath, selectedWorkflow);
+    s.stop(`Knowledge base "${name}" created`);
+    const createdKnowledgeBaseConfig = readInterfConfig(knowledgeBasePath);
+    if (createdKnowledgeBaseConfig?.workflow) {
+        p.log.info(`Workflow: ${createdKnowledgeBaseConfig.workflow}`);
+    }
+    // Discovery preflight
+    const discovery = discoverSourceFiles(cwd, knowledgeBasePath);
+    p.log.info(`Found ${discovery.totalCount} source files ready to summarize and compile.`);
+    if (discovery.ignoredCount > 0) {
+        p.log.info("This count already excludes Interf files, hidden folders, and anything matched by `.interfignore`.");
+    }
+    if (loadUserConfig()?.viewer === "obsidian") {
+        p.log.info(`Obsidian defaults applied; knowledge base registered with Obsidian when available as "${name}".`);
+    }
+    const buildNow = await p.confirm({
+        message: "Compile this knowledge base now?",
+        initialValue: true,
+    });
+    if (p.isCancel(buildNow))
+        return;
+    if (buildNow) {
+        const { executor, error } = resolveLocalExecutor();
+        if (!executor) {
+            p.log.warn(error ?? "No local executor detected.");
+            p.outro([
+                `Knowledge base: ${knowledgeBasePath}`,
+                `Next: run \`interf compile\` from ${cwd} once an executor is configured.`,
+            ].join("\n"));
+            return;
+        }
+        const compiled = await runKnowledgeBaseCompile(executor, knowledgeBasePath);
+        if (compiled) {
+            const createFirstInterface = await p.confirm({
+                message: "Create a first interface now?",
+                initialValue: false,
+            });
+            if (p.isCancel(createFirstInterface))
+                return;
+            if (createFirstInterface) {
+                await createInterfaceWizard({
+                    intro: false,
+                    knowledgeBasePathOverride: knowledgeBasePath,
+                    knowledgeBaseNameOverride: name,
+                });
+                return;
+            }
+            p.outro([
+                `Knowledge base ready: ${knowledgeBasePath}`,
+                `CLI control plane: ${cwd}`,
+                `Workspace entrypoint: ${knowledgeBasePath}`,
+                `Browse in Obsidian or markdown from: ${knowledgeBasePath}`,
+                `Next: \`interf create interface\` from ${cwd} when you want a focused interface for a specific job.`,
+            ].join("\n"));
+            return;
+        }
+        p.outro([
+            `Knowledge base created: ${knowledgeBasePath}`,
+            `The compile did not complete cleanly.`,
+            `Next: rerun \`cd ${knowledgeBasePath} && interf compile\` after fixing the reported issue, or run \`interf compile\` from ${cwd}.`,
+        ].join("\n"));
+        return;
+    }
+    p.outro([
+        `Knowledge base created: ${knowledgeBasePath}`,
+        `CLI control plane: ${cwd}`,
+        `Workspace entrypoint: ${knowledgeBasePath}`,
+        `Next: run \`cd ${knowledgeBasePath} && interf compile\`, or run \`interf compile\` from ${cwd}.`,
+    ].join("\n"));
+}
+export async function createInterfaceWizard(options = {}) {
+    if (options.intro !== false) {
+        p.intro(chalk.bold("Create an interface"));
+    }
+    p.log.info("An interface is a focused layer on top of a knowledge base.");
+    p.log.info("Use it for one job, perspective, or workflow. It keeps local outputs, a local workflow package, and its own agent instructions while reusing knowledge-base evidence.");
+    // Find the knowledge-base — either cwd has interf/ or we look up registry
+    const cwd = process.cwd();
+    const detected = detectInterf(cwd);
+    const localKnowledgeBases = listKnowledgeBasesForSourceFolder(cwd);
+    let knowledgeBasePath;
+    let connectedKnowledgeBaseName;
+    if (options.knowledgeBasePathOverride && options.knowledgeBaseNameOverride) {
+        knowledgeBasePath = options.knowledgeBasePathOverride;
+        connectedKnowledgeBaseName = options.knowledgeBaseNameOverride;
+    }
+    else if (detected && detected.config.type === "knowledge-base") {
+        const useCurrentKnowledgeBase = await p.confirm({
+            message: `Use the current knowledge base "${detected.config.name}"?`,
+            initialValue: true,
+        });
+        if (p.isCancel(useCurrentKnowledgeBase))
+            return;
+        if (useCurrentKnowledgeBase) {
+            knowledgeBasePath = detected.path;
+            connectedKnowledgeBaseName = detected.config.name;
+        }
+        else {
+            const availableKnowledgeBases = [
+                ...localKnowledgeBases
+                    .filter((knowledgeBase) => knowledgeBase.path !== detected.path)
+                    .map((knowledgeBase) => ({
+                    path: knowledgeBase.path,
+                    name: knowledgeBase.config.name,
+                    label: `${knowledgeBase.config.name} (${knowledgeBase.path})`,
+                })),
+                ...loadRegistry().knowledgeBases
+                    .filter((knowledgeBase) => knowledgeBase.path !== detected.path)
+                    .map((knowledgeBase) => ({
+                    path: knowledgeBase.path,
+                    name: knowledgeBase.name,
+                    label: `${knowledgeBase.name} (${knowledgeBase.path})`,
+                })),
+            ];
+            const uniqueKnowledgeBases = Array.from(new Map(availableKnowledgeBases.map((knowledgeBase) => [knowledgeBase.path, knowledgeBase])).values());
+            if (uniqueKnowledgeBases.length === 0) {
+                p.log.error("No other knowledge bases found. Use the current one or create another knowledge base first.");
+                return;
+            }
+            const choice = await p.select({
+                message: "Which knowledge base?",
+                options: uniqueKnowledgeBases.map((knowledgeBase) => ({
+                    value: knowledgeBase.path,
+                    label: knowledgeBase.label,
+                })),
+            });
+            if (p.isCancel(choice))
+                return;
+            const knowledgeBase = uniqueKnowledgeBases.find((entry) => entry.path === choice);
+            knowledgeBasePath = knowledgeBase.path;
+            connectedKnowledgeBaseName = knowledgeBase.name;
+        }
+    }
+    else if (localKnowledgeBases.length > 0) {
+        const choice = await p.select({
+            message: "Which local knowledge base?",
+            options: localKnowledgeBases.map((knowledgeBase) => ({
+                value: knowledgeBase.path,
+                label: `${knowledgeBase.config.name} (${knowledgeBase.path})`,
+            })),
+        });
+        if (p.isCancel(choice))
+            return;
+        const knowledgeBase = localKnowledgeBases.find((entry) => entry.path === choice);
+        knowledgeBasePath = knowledgeBase.path;
+        connectedKnowledgeBaseName = knowledgeBase.config.name;
+    }
+    else {
+        const reg = loadRegistry();
+        if (reg.knowledgeBases.length === 0) {
+            p.log.error("No knowledge bases found. Create one first: interf create knowledge-base");
+            return;
+        }
+        const choice = await p.select({
+            message: "Which knowledge base?",
+            options: reg.knowledgeBases.map((knowledgeBase) => ({
+                value: knowledgeBase.path,
+                label: `${knowledgeBase.name} (${knowledgeBase.path})`,
+            })),
+        });
+        if (p.isCancel(choice))
+            return;
+        const knowledgeBase = reg.knowledgeBases.find((entry) => entry.path === choice);
+        knowledgeBasePath = knowledgeBase.path;
+        connectedKnowledgeBaseName = knowledgeBase.name;
+    }
+    const rawName = await p.text({
+        message: "Interface name?",
+        placeholder: "weekly-briefing",
+        validate: (v) => (v.length === 0 ? "Name is required" : undefined),
+    });
+    if (p.isCancel(rawName))
+        return;
+    const name = slugify(rawName);
+    if (name !== rawName) {
+        p.log.info(`Directory name: ${name}`);
+    }
+    const workflow = await chooseInterfaceWorkflow(knowledgeBasePath);
+    if (p.isCancel(workflow))
+        return;
+    const selectedWorkflow = workflow;
+    const workflowInfo = [
+        ...listKnowledgeBaseInterfaceWorkflowChoices(knowledgeBasePath),
+        ...listInterfaceWorkflowChoices(resolveKnowledgeBaseSourcePath(knowledgeBasePath)),
+    ].find((option) => option.id === selectedWorkflow);
+    const interfaceStageSequence = workflowInfo.stages.map((stage) => stage.label).join(" -> ");
+    p.log.info(`Interface workflow = the default ${interfaceStageSequence} method for this interface. You can edit it later in \`workflow/\` or create your own saved workflow.`);
+    p.log.info(`${workflowInfo.label}: ${workflowInfo.hint}`);
+    const useCase = await p.text({
+        message: "Primary question or job for this interface?",
+        placeholder: workflowInfo.placeholder,
+        validate: (v) => (v.trim().length === 0 ? "Describe the main job for this interface" : undefined),
+    });
+    if (p.isCancel(useCase))
+        return;
+    const { executor, error } = resolveLocalExecutor();
+    if (!executor) {
+        p.log.error(error ?? "No coding agent detected. Install Claude Code or Codex to create interfaces.");
+        return;
+    }
+    let dirPath;
+    try {
+        dirPath = createInterface(name, knowledgeBasePath, connectedKnowledgeBaseName, selectedWorkflow);
+    }
+    catch (error) {
+        p.log.error(error instanceof Error ? error.message : "Failed to create interface scaffold.");
+        return;
+    }
+    if (loadUserConfig()?.viewer === "obsidian") {
+        p.log.info("Obsidian defaults applied. Interfaces stay inside the parent knowledge-base vault by default so knowledge-base summaries and source links remain navigable.");
+    }
+    p.log.info(`Created interface scaffold at ${dirPath}`);
+    const createdInterfaceConfig = readInterfConfig(dirPath);
+    if (createdInterfaceConfig?.workflow) {
+        p.log.info(`Workflow: ${createdInterfaceConfig.workflow}`);
+    }
+    writeInterfaceCompilePlanTemplate(dirPath, {
+        workflowId: selectedWorkflow,
+        sourcePath: resolveKnowledgeBaseSourcePath(knowledgeBasePath),
+        interfaceName: name,
+        useCase: useCase.trim(),
+    });
+    p.log.info("Spawning agent to analyze the knowledge base and refine the interface plan.");
+    const result = await planInterface({
+        executor,
+        knowledgeBasePath: dirPath,
+        name,
+        workflow: selectedWorkflow,
+        useCase: useCase,
+        knowledgeBaseName: connectedKnowledgeBaseName,
+    });
+    if (result.ok) {
+        addInterface(name, dirPath, connectedKnowledgeBaseName, knowledgeBasePath, selectedWorkflow);
+        const buildNow = await p.confirm({
+            message: "Compile this interface now?",
+            initialValue: true,
+        });
+        if (p.isCancel(buildNow))
+            return;
+        if (buildNow) {
+            const built = await runInterfaceCompile(executor, dirPath);
+            if (built) {
+                p.outro([
+                    `Interface ready: ${dirPath}`,
+                    `CLI control plane: ${resolveSourceManagementRoot(knowledgeBasePath)}`,
+                    `Workspace entrypoint: ${dirPath}`,
+                    `Browse it from the knowledge base at: ${knowledgeBasePath}`,
+                ].join("\n"));
+                return;
+            }
+            p.outro([
+                `Interface created: ${dirPath}`,
+                `The compile did not complete cleanly.`,
+                `Next: rerun \`cd ${dirPath} && interf compile\` after fixing the reported issue, or run \`interf compile\` from the source folder.`,
+            ].join("\n"));
+            return;
+        }
+        p.outro([
+            `Interface created: ${dirPath}`,
+            `CLI control plane: ${resolveSourceManagementRoot(knowledgeBasePath)}`,
+            `Workspace entrypoint: ${dirPath}`,
+            `Next: run \`cd ${dirPath} && interf compile\`, or run \`interf compile\` from ${resolveSourceManagementRoot(knowledgeBasePath)}.`,
+        ].join("\n"));
+    }
+    else {
+        const failureSummary = result.summary?.trim();
+        writeInterfaceCompilePlanTemplate(dirPath, {
+            workflowId: selectedWorkflow,
+            sourcePath: resolveKnowledgeBaseSourcePath(knowledgeBasePath),
+            interfaceName: name,
+            useCase: useCase.trim(),
+        });
+        addInterface(name, dirPath, connectedKnowledgeBaseName, knowledgeBasePath, selectedWorkflow);
+        p.log.warn(failureSummary
+            ? `${failureSummary} Restored the starter interface plan from the selected workflow.`
+            : `Agent exited with code ${result.code}. Restored the starter interface plan from the selected workflow.`);
+        p.outro([
+            `Interface created: ${dirPath}`,
+            failureSummary
+                ? `The refined interface scaffold did not pass validation: ${failureSummary}`
+                : "The agent could not finish refining the plan, but the starter compile plan is valid and editable.",
+            `CLI control plane: ${resolveSourceManagementRoot(knowledgeBasePath)}`,
+            `Workspace entrypoint: ${dirPath}`,
+            `Next: review \`compile-plan.md\`, then run \`cd ${dirPath} && interf compile\`, or run \`interf compile\` from ${resolveSourceManagementRoot(knowledgeBasePath)}.`,
+        ].join("\n"));
+    }
+}
+function createWizardReporter() {
+    return {
+        line: (message) => console.log(chalk.dim(`  ${message}`)),
+        blankLine: () => console.log(),
+    };
+}
+async function runKnowledgeBaseCompile(executor, knowledgeBasePath) {
+    console.log();
+    console.log(chalk.bold("  Compiling knowledge base..."));
+    console.log();
+    const result = await compileKnowledgeBaseWorkflow({
+        executor,
+        knowledgeBasePath,
+        reporter: createWizardReporter(),
+    });
+    if (!result.ok) {
+        const workflowId = resolveKnowledgeBaseWorkflowFromConfig(readInterfConfig(knowledgeBasePath));
+        const failedStage = formatKnowledgeBaseWorkflowStageStep(workflowId, result.failedStage ?? "compile", { workspacePath: knowledgeBasePath });
+        console.log(chalk.red(`  ${failedStage} failed.`));
+        return false;
+    }
+    console.log();
+    console.log(chalk.green("  ✓ Knowledge base ready."));
+    return true;
+}
+async function runInterfaceCompile(executor, interfacePath) {
+    console.log();
+    console.log(chalk.bold("  Compiling interface..."));
+    console.log();
+    const result = await compileInterfaceWorkflow({
+        executor,
+        knowledgeBasePath: interfacePath,
+        reporter: createWizardReporter(),
+    });
+    if (!result.ok) {
+        const workflowId = resolveInterfaceWorkflowFromConfig(readInterfConfig(interfacePath));
+        const failedStage = formatInterfaceWorkflowStageStep(workflowId, result.failedStage ?? "compile", { workspacePath: interfacePath });
+        console.log(chalk.red(`  ${failedStage} failed.`));
+        return false;
+    }
+    console.log();
+    console.log(chalk.green("  ✓ Interface ready."));
+    return true;
+}
+function resolveSourceManagementRoot(knowledgeBasePath) {
+    return resolveKnowledgeBaseSourcePath(knowledgeBasePath);
+}
+//# sourceMappingURL=create.js.map