@msn-control/liftoff 0.4.0 → 0.5.0

package/dist/interactive.d.ts

@@ -1,8 +1,82 @@
-import type { ProjectOptions, ProjectPlan } from './types.js';
+import type { Readable } from 'node:stream';
 import type { DependencyCommandPlan } from './project-dependencies.js';
-export declare function promptForInitOptions(initial: ProjectOptions): Promise<ProjectOptions>;
-export declare function confirmPlan(plan: ProjectPlan, yes?: boolean): Promise<boolean>;
-export declare function confirmToolInstallation(detail: string): Promise<boolean>;
-export declare function confirmFileReplacements(paths: readonly string[]): Promise<boolean>;
-export declare function confirmDependencyInstallation(commands: DependencyCommandPlan[]): Promise<boolean>;
+import { type CommandRunner } from './process-runner.js';
+import { PresentationSession } from './terminal.js';
+import type { CodingAgentId, ProjectOptions, ProjectPlan } from './types.js';
+interface AgentCheckboxChoice {
+    name: string;
+    value: CodingAgentId;
+    checked: boolean;
+}
+export type AgentCheckboxPrompt = (config: {
+    message: string;
+    choices: AgentCheckboxChoice[];
+    required: boolean;
+    validate: (selected: readonly CodingAgentId[]) => true | string;
+}, context: {
+    input: Readable;
+    output: NodeJS.WritableStream;
+}) => Promise<CodingAgentId[]>;
+export interface InteractiveDependencies {
+    input?: Readable;
+    output?: NodeJS.WritableStream;
+    presentation?: PresentationSession;
+    cwd?: string;
+    configuredRoot?: string;
+    runner?: CommandRunner;
+    checkboxPrompt?: AgentCheckboxPrompt;
+}
+export interface ToolInstallationPrompt {
+    label: string;
+    severity: string;
+    purpose: string;
+    requirement: string;
+    observed: string;
+    command?: string;
+    remedy?: string;
+}
+export declare class InteractiveCancelledError extends Error {
+    constructor(message?: string);
+}
+export declare class InteractivePrompter {
+    private readonly input;
+    private readonly output;
+    private readonly presentation;
+    private readonly cwd;
+    private readonly configuredRoot?;
+    private readonly runner?;
+    private readonly checkboxPrompt?;
+    private rl?;
+    private lines?;
+    private closed;
+    constructor(dependencies?: InteractiveDependencies);
+    close(): void;
+    promptForInitOptions(initial: ProjectOptions): Promise<ProjectOptions>;
+    confirmPlan(plan: ProjectPlan, yes?: boolean, actionLabel?: string): Promise<boolean>;
+    confirmToolInstallation(prompt: ToolInstallationPrompt | string): Promise<boolean>;
+    confirmFileReplacements(paths: readonly string[]): Promise<boolean>;
+    confirmDependencyInstallation(commands: DependencyCommandPlan[]): Promise<boolean>;
+    private askRequired;
+    private choose;
+    private confirm;
+    private promptForRegion;
+    private chooseRegion;
+    private askEnvironments;
+    private askAgents;
+    private askAgentsWithLines;
+    private askAgentsWithCheckbox;
+    private discoverAgents;
+    private pathExists;
+    private agentChoiceLabel;
+    private isRealTty;
+    private question;
+    private lineIterator;
+    private releaseLineInput;
+}
+export declare function promptForInitOptions(initial: ProjectOptions, dependencies?: InteractiveDependencies): Promise<ProjectOptions>;
+export declare function confirmPlan(plan: ProjectPlan, yes?: boolean, dependencies?: InteractiveDependencies, actionLabel?: string): Promise<boolean>;
+export declare function confirmToolInstallation(prompt: ToolInstallationPrompt | string, dependencies?: InteractiveDependencies): Promise<boolean>;
+export declare function confirmFileReplacements(paths: readonly string[], dependencies?: InteractiveDependencies): Promise<boolean>;
+export declare function confirmDependencyInstallation(commands: DependencyCommandPlan[], dependencies?: InteractiveDependencies): Promise<boolean>;
 export declare function resolveCatalogInput(options: ProjectOptions): ProjectOptions;
+export {};

package/dist/interactive.js

@@ -1,52 +1,116 @@
+import { access } from 'node:fs/promises';
+import path from 'node:path';
+import { stdin as processInput, stdout as processOutput } from 'node:process';
 import { createInterface } from 'node:readline/promises';
-import { stdin as input, stdout as output } from 'node:process';
-import { apiStacks, codingAgents, environments, getApiStack, getCodingAgent, getPattern, getProjectType, getProvider, getSpecWorkflow, patterns, providers, resolveRegion, specWorkflows } from './catalogs.js';
-import { formatProjectPlan } from './planner.js';
+import { apiStacks, codingAgents, environments, getApiStack, getCodingAgent, getFrameworkDefinition, getPattern, getProjectType, getProvider, getSpecWorkflow, patterns, projectTypes, providers, resolveRegion, specWorkflows } from './catalogs.js';
+import { projectPlanEntries } from './planner.js';
 import { formatCommand } from './process-runner.js';
-export async function promptForInitOptions(initial) {
-    const rl = createInterface({ input, output });
-    try {
-        const projectName = initial.projectName ?? await askRequired(rl, 'Project name');
+import { PresentationSession } from './terminal.js';
+export class InteractiveCancelledError extends Error {
+    constructor(message = 'Interactive initialization was cancelled.') {
+        super(message);
+        this.name = 'InteractiveCancelledError';
+    }
+}
+function errorCode(error) {
+    return typeof error === 'object' && error !== null && 'code' in error &&
+        typeof error.code === 'string'
+        ? error.code
+        : undefined;
+}
+function isPromptCancellation(error) {
+    return error instanceof Error && (error.name === 'ExitPromptError' ||
+        error.name === 'AbortPromptError' ||
+        error.message.includes('User force closed the prompt'));
+}
+export class InteractivePrompter {
+    input;
+    output;
+    presentation;
+    cwd;
+    configuredRoot;
+    runner;
+    checkboxPrompt;
+    rl;
+    lines;
+    closed = false;
+    constructor(dependencies = {}) {
+        this.input = dependencies.input ?? processInput;
+        this.output = dependencies.output ?? processOutput;
+        this.presentation = dependencies.presentation ?? new PresentationSession({
+            stdout: this.output,
+            stderr: this.output
+        });
+        this.cwd = dependencies.cwd ?? process.cwd();
+        this.configuredRoot = dependencies.configuredRoot;
+        this.runner = dependencies.runner;
+        this.checkboxPrompt = dependencies.checkboxPrompt;
+    }
+    close() {
+        this.closed = true;
+        this.releaseLineInput();
+    }
+    async promptForInitOptions(initial) {
+        const projectName = initial.projectName ?? await this.askRequired('Project name');
         const inferredProjectType = initial.projectType ?? (initial.pattern ? 'genai' : initial.apiStack ? 'standard' : undefined);
-        const projectType = inferredProjectType ?? (await confirm(rl, 'Is this a GenAI project?', true) ? 'genai' : 'standard');
+        const projectType = inferredProjectType ??
+            await this.choose('Select workload', projectTypes.map((workload) => ({
+                value: workload.id,
+                label: workload.label,
+                disabled: false
+            })), 'genai');
         const pattern = projectType === 'genai'
-            ? initial.pattern ?? await choose(rl, 'Select GenAI pattern', patterns.map((pattern) => ({
+            ? initial.pattern ?? await this.choose('Select GenAI pattern', patterns.map((pattern) => ({
                 value: pattern.id,
                 label: `${pattern.label} (${pattern.scaffoldStatus})`,
                 disabled: false
             })))
             : initial.pattern;
         const apiStack = projectType === 'standard'
-            ? initial.apiStack ?? await choose(rl, 'Select API stack', apiStacks.map((stack) => ({
+            ? initial.apiStack ?? await this.choose('Select API stack', apiStacks.map((stack) => ({
                 value: stack.id,
                 label: `${stack.label} (${stack.databaseTooling})`,
                 disabled: false
             })), 'python-fastapi')
-            : initial.apiStack ?? 'python-fastapi';
-        const cloud = initial.cloud ?? await choose(rl, 'Target cloud', providers.map((provider) => ({
-            value: provider.id,
-            label: `${provider.label}${provider.status === 'planned' ? ' - planned' : ''}`,
-            disabled: provider.status === 'planned'
-        })));
-        const region = initial.region ?? await promptForRegion(rl, cloud);
-        const includeFrontend = initial.includeFrontend ?? await confirm(rl, 'Include frontend? (Vue 3 + Tailwind)', false);
-        const specWorkflow = initial.specWorkflow ?? await choose(rl, 'Select spec-driven workflow', specWorkflows.map((workflow) => ({
+            : projectType === 'genai'
+                ? initial.apiStack ?? 'python-fastapi'
+                : initial.apiStack;
+        const cloud = projectType === 'power-apps-code-app'
+            ? initial.cloud
+            : initial.cloud ?? await this.choose('Target cloud', providers.map((provider) => ({
+                value: provider.id,
+                label: `${provider.label}${provider.status === 'planned' ? ' - planned' : ''}`,
+                disabled: provider.status === 'planned'
+            })));
+        const region = projectType === 'power-apps-code-app'
+            ? initial.region
+            : initial.region ?? await this.promptForRegion(cloud);
+        const includeFrontend = projectType === 'power-apps-code-app'
+            ? initial.includeFrontend
+            : initial.includeFrontend ?? await this.confirm('Include frontend? (Vue 3 + Tailwind)', false);
+        const specWorkflow = initial.specWorkflow ?? await this.choose('Select spec-driven workflow', specWorkflows.map((workflow) => ({
             value: workflow.id,
-            label: `${workflow.label}${workflow.default ? ' (default)' : ''}`,
+            label: workflow.label,
             disabled: false
         })), 'openspec');
-        const selectedAgents = initial.agents ?? await askAgents(rl);
+        const selectedAgents = initial.agents ?? await this.askAgents(specWorkflow);
         const normalizedAgents = selectedAgents
             .map((agent) => getCodingAgent(agent)?.id)
             .filter((agent) => agent !== undefined);
         const defaultAgent = specWorkflow === 'spec-kit' && normalizedAgents.length > 1
-            ? initial.defaultAgent ?? await choose(rl, 'Select the default Spec Kit agent', codingAgents
+            ? initial.defaultAgent ?? await this.choose('Select the default Spec Kit agent', codingAgents
                 .filter((agent) => normalizedAgents.includes(agent.id))
                 .map((agent) => ({ value: agent.id, label: agent.label, disabled: false })), normalizedAgents[0])
             : specWorkflow === 'spec-kit'
                 ? normalizedAgents[0]
                 : undefined;
-        const selectedEnvironments = initial.environments ?? await askEnvironments(rl);
+        const codeAppsPlugin = projectType === 'power-apps-code-app'
+            ? initial.codeAppsPlugin ??
+                await this.confirm('Include Microsoft Code Apps preview plugin guidance?', false)
+            : initial.codeAppsPlugin;
+        const selectedEnvironments = projectType === 'power-apps-code-app'
+            ? initial.environments
+            : initial.environments ?? await this.askEnvironments();
         return {
             ...initial,
             projectName,
@@ -59,158 +123,290 @@ export async function promptForInitOptions(initial) {
             specWorkflow,
             agents: normalizedAgents,
             ...(defaultAgent ? { defaultAgent } : {}),
-            environments: selectedEnvironments
+            ...(selectedEnvironments ? { environments: selectedEnvironments } : {}),
+            ...(codeAppsPlugin !== undefined ? { codeAppsPlugin } : {})
         };
     }
-    finally {
-        rl.close();
+    async confirmPlan(plan, yes, actionLabel = 'Initialize project?') {
+        this.presentation.definitions('Resolved project plan', projectPlanEntries(plan));
+        return yes ? true : this.confirm(actionLabel, true);
     }
-}
-export async function confirmPlan(plan, yes) {
-    if (yes) {
-        return true;
+    async confirmToolInstallation(prompt) {
+        if (typeof prompt === 'string') {
+            this.presentation.section('Workstation tool requiring action', prompt.split(/\r?\n/));
+        }
+        else {
+            this.presentation.definitions('Workstation tool requiring action', [
+                { label: 'Tool', value: `${prompt.label} [${prompt.severity}]` },
+                { label: 'Purpose', value: prompt.purpose },
+                { label: 'Requirement', value: prompt.requirement },
+                { label: 'Observed', value: prompt.observed }
+            ]);
+            if (prompt.command) {
+                this.presentation.command(prompt.command);
+            }
+            if (prompt.remedy) {
+                this.presentation.remedy(prompt.remedy);
+            }
+        }
+        return this.confirm('Run this allowlisted installation command?', false);
     }
-    const rl = createInterface({ input, output });
-    try {
-        output.write(`\nGenerated plan:\n${formatProjectPlan(plan)}\n\n`);
-        return await confirm(rl, 'Initialize project?', true);
+    async confirmFileReplacements(paths) {
+        this.presentation.bullets('Existing regular files with different content', paths);
+        return this.confirm('Replace every listed file?', false);
     }
-    finally {
-        rl.close();
+    async confirmDependencyInstallation(commands) {
+        this.presentation.table('Project dependency commands', ['Purpose', 'Working directory', 'Command'], commands.map((command) => [
+            command.label,
+            command.cwd,
+            formatCommand(command.command)
+        ]));
+        return this.confirm('Install project-local dependencies now?', false);
     }
-}
-async function askRequired(rl, label) {
-    while (true) {
-        const answer = (await rl.question(`? ${label}: `)).trim();
-        if (answer) {
-            return answer;
+    async askRequired(label) {
+        while (true) {
+            const answer = (await this.question(label)).trim();
+            if (answer) {
+                return answer;
+            }
+            this.presentation.warning(`${label} is required.`);
         }
     }
-}
-async function choose(rl, label, options, defaultValue) {
-    while (true) {
-        output.write(`? ${label}:\n`);
-        options.forEach((option, index) => {
-            output.write(`  ${index + 1}. ${option.label}\n`);
-        });
-        const answer = (await rl.question('Select option: ')).trim();
-        if (!answer && defaultValue) {
+    async choose(label, options, defaultValue) {
+        while (true) {
+            this.presentation.choices(label, options.map((option) => ({
+                label: option.label,
+                value: option.value,
+                disabled: option.disabled,
+                default: option.value === defaultValue
+            })));
+            const answer = (await this.question('Select option', defaultValue)).trim();
+            if (!answer && defaultValue) {
+                return defaultValue;
+            }
+            const selectedIndex = Number(answer) - 1;
+            const selected = options[selectedIndex] ?? options.find((option) => option.value === answer);
+            if (!selected) {
+                this.presentation.warning('Please choose a valid option.');
+                continue;
+            }
+            if (selected.disabled) {
+                this.presentation.warning(`${selected.label} is not available in V1.`);
+                continue;
+            }
+            return selected.value;
+        }
+    }
+    async confirm(label, defaultValue) {
+        const suffix = defaultValue ? 'Y/n' : 'y/N';
+        const answer = (await this.question(label, suffix)).trim().toLowerCase();
+        if (!answer) {
             return defaultValue;
         }
-        const selectedIndex = Number(answer) - 1;
-        const selected = options[selectedIndex] ?? options.find((option) => option.value === answer);
-        if (!selected) {
-            output.write('Please choose a valid option.\n');
-            continue;
+        return answer === 'y' || answer === 'yes';
+    }
+    async promptForRegion(cloud) {
+        const provider = getProvider(cloud);
+        if (!provider || provider.id !== 'azure') {
+            return '';
         }
-        if (selected.disabled) {
-            output.write(`${selected.label} is not available in V1.\n`);
-            continue;
+        while (true) {
+            const answer = (await this.question('Azure region', 'East US / eastus')).trim();
+            const resolution = resolveRegion(provider.id, answer);
+            if (resolution.status === 'resolved') {
+                return resolution.region.slug;
+            }
+            if (resolution.status === 'ambiguous') {
+                const selected = await this.chooseRegion(resolution.matches);
+                return selected.slug;
+            }
+            this.presentation.warning(`Unknown Azure region: ${resolution.input}. Try a region name such as eastus or korea.`);
         }
-        return selected.value;
     }
-}
-async function confirm(rl, label, defaultValue) {
-    const suffix = defaultValue ? 'Y/n' : 'y/N';
-    const answer = (await rl.question(`? ${label} [${suffix}]: `)).trim().toLowerCase();
-    if (!answer) {
-        return defaultValue;
+    async chooseRegion(matches) {
+        this.presentation.table('Matching Azure regions', ['Option', 'Region', 'Identifier'], matches.map((region, index) => [`${index + 1}`, region.displayName, region.slug]));
+        while (true) {
+            const answer = (await this.question('Select deployment region')).trim();
+            const selected = matches[Number(answer) - 1] ??
+                matches.find((region) => region.slug === answer);
+            if (selected) {
+                return selected;
+            }
+            this.presentation.warning('Please choose a valid deployment region.');
+        }
     }
-    return answer === 'y' || answer === 'yes';
-}
-async function promptForRegion(rl, cloud) {
-    const provider = getProvider(cloud);
-    if (!provider || provider.id !== 'azure') {
-        return '';
+    async askEnvironments() {
+        const answer = (await this.question('Environments', 'dev,test,prod')).trim();
+        if (!answer) {
+            return environments.map((environment) => environment.id);
+        }
+        return answer.split(',').map((value) => value.trim()).filter(Boolean);
     }
-    while (true) {
-        const answer = (await rl.question('? Azure region [East US / eastus]: ')).trim();
-        const resolution = resolveRegion(provider.id, answer);
-        if (resolution.status === 'resolved') {
-            return resolution.region.slug;
+    async askAgents(specWorkflow) {
+        const discovery = await this.discoverAgents(specWorkflow);
+        if (this.isRealTty()) {
+            return this.askAgentsWithCheckbox(discovery);
         }
-        if (resolution.status === 'ambiguous') {
-            const selected = await chooseRegion(rl, resolution.matches);
-            return selected.slug;
+        return this.askAgentsWithLines(discovery);
+    }
+    async askAgentsWithLines(discovery) {
+        while (true) {
+            this.presentation.choices('Select one or more AI coding agents', codingAgents.map((agent) => ({
+                label: this.agentChoiceLabel(agent.id, discovery),
+                value: agent.id,
+                default: discovery.defaults.includes(agent.id),
+                selected: discovery.defaults.includes(agent.id)
+            })));
+            const defaultSelection = discovery.defaults
+                .map((agentId) => `${codingAgents.findIndex((agent) => agent.id === agentId) + 1}`)
+                .join(',');
+            const answer = (await this.question('Select comma-separated options', defaultSelection)).trim() || defaultSelection;
+            const selected = answer.split(',').map((value) => value.trim()).filter(Boolean);
+            const resolved = selected.map((value) => {
+                const byIndex = codingAgents[Number(value) - 1];
+                return byIndex ?? getCodingAgent(value);
+            });
+            if (resolved.some((agent) => !agent)) {
+                this.presentation.warning('Please choose valid agent options.');
+                continue;
+            }
+            return codingAgents
+                .filter((agent) => resolved.some((selectedAgent) => selectedAgent?.id === agent.id))
+                .map((agent) => agent.id);
         }
-        output.write(`Unknown Azure region: ${resolution.input}. Try a region name such as eastus or korea.\n`);
     }
-}
-async function chooseRegion(rl, matches) {
-    output.write('Found matching Azure regions:\n');
-    matches.forEach((region, index) => {
-        output.write(`  ${index + 1}. ${region.displayName}    ${region.slug}\n`);
-    });
-    while (true) {
-        const answer = (await rl.question('Select deployment region: ')).trim();
-        const selected = matches[Number(answer) - 1] ?? matches.find((region) => region.slug === answer);
-        if (selected) {
-            return selected;
+    async askAgentsWithCheckbox(discovery) {
+        this.releaseLineInput();
+        try {
+            const checkbox = this.checkboxPrompt ?? (await import('@inquirer/prompts')).checkbox;
+            const selected = await checkbox({
+                message: 'Select one or more AI coding agents',
+                choices: codingAgents.map((agent) => ({
+                    name: this.agentChoiceLabel(agent.id, discovery),
+                    value: agent.id,
+                    checked: discovery.defaults.includes(agent.id)
+                })),
+                required: true,
+                validate: (values) => values.length > 0 || 'Select at least one AI coding agent.'
+            }, {
+                input: this.input,
+                output: this.output
+            });
+            return codingAgents
+                .filter((agent) => selected.includes(agent.id))
+                .map((agent) => agent.id);
+        }
+        catch (error) {
+            if (isPromptCancellation(error)) {
+                throw new InteractiveCancelledError();
+            }
+            throw error;
         }
     }
-}
-async function askEnvironments(rl) {
-    const answer = (await rl.question('? Environments [dev,test,prod]: ')).trim();
-    if (!answer) {
-        return environments.map((environment) => environment.id);
+    async discoverAgents(specWorkflow) {
+        const configured = new Set();
+        const detected = new Set();
+        const framework = getFrameworkDefinition(specWorkflow);
+        await Promise.all(codingAgents.map(async (agent) => {
+            if (this.configuredRoot) {
+                const markerStates = await Promise.all(framework.agentMarkers[agent.id].map(async (pathParts) => this.pathExists(path.join(this.configuredRoot, ...pathParts))));
+                if (markerStates.some(Boolean)) {
+                    configured.add(agent.id);
+                }
+            }
+            if (this.runner) {
+                const probe = await this.runner.run({ executable: agent.executable, args: ['--version'] }, { cwd: this.cwd, timeoutMs: 10_000 });
+                if (probe.status === 0 && !probe.timedOut) {
+                    detected.add(agent.id);
+                }
+            }
+        }));
+        const defaults = codingAgents
+            .filter((agent) => configured.size > 0
+            ? configured.has(agent.id)
+            : detected.size > 0
+                ? detected.has(agent.id)
+                : agent.id === 'github-copilot')
+            .map((agent) => agent.id);
+        return { configured, detected, defaults };
     }
-    return answer.split(',').map((value) => value.trim()).filter(Boolean);
-}
-async function askAgents(rl) {
-    while (true) {
-        output.write('? Select one or more AI coding agents:\n');
-        codingAgents.forEach((agent, index) => {
-            output.write(`  ${index + 1}. ${agent.label}${agent.id === 'github-copilot' ? ' (default)' : ''}\n`);
-        });
-        const answer = (await rl.question('Select comma-separated options [1]: ')).trim() || '1';
-        const selected = answer.split(',').map((value) => value.trim()).filter(Boolean);
-        const resolved = selected.map((value) => {
-            const byIndex = codingAgents[Number(value) - 1];
-            return byIndex ?? getCodingAgent(value);
-        });
-        if (resolved.some((agent) => !agent)) {
-            output.write('Please choose valid agent options.\n');
-            continue;
+    async pathExists(file) {
+        try {
+            await access(file);
+            return true;
+        }
+        catch (error) {
+            if (errorCode(error) === 'ENOENT' || errorCode(error) === 'ENOTDIR') {
+                return false;
+            }
+            throw error;
         }
-        return codingAgents
-            .filter((agent) => resolved.some((selectedAgent) => selectedAgent?.id === agent.id))
-            .map((agent) => agent.id);
     }
-}
-export async function confirmToolInstallation(detail) {
-    const rl = createInterface({ input, output });
-    try {
-        output.write(`\nWorkstation tool requiring action:\n${detail}\n\n`);
-        return await confirm(rl, 'Run this allowlisted installation command?', false);
+    agentChoiceLabel(agentId, discovery) {
+        const agent = codingAgents.find((candidate) => candidate.id === agentId);
+        if (!agent) {
+            throw new Error(`Unknown coding agent: ${agentId}`);
+        }
+        const states = [
+            discovery.configured.has(agentId) ? 'configured' : undefined,
+            discovery.detected.has(agentId) ? 'detected' : undefined
+        ].filter((state) => state !== undefined);
+        return `${agent.label} (${states.length > 0 ? states.join(', ') : 'not observable'})`;
     }
-    finally {
-        rl.close();
+    isRealTty() {
+        const input = this.input;
+        const output = this.output;
+        return input.isTTY === true && typeof input.setRawMode === 'function' && output.isTTY === true;
     }
-}
-export async function confirmFileReplacements(paths) {
-    const rl = createInterface({ input, output });
-    try {
-        output.write(`\nExisting regular files with different content:\n${paths.map((file) => `- ${file}`).join('\n')}\n\n`);
-        return await confirm(rl, 'Replace every listed file?', false);
+    async question(label, defaultValue) {
+        this.presentation.prompt(label, defaultValue);
+        const answer = await this.lineIterator().next();
+        if (answer.done) {
+            throw new InteractiveCancelledError(`Interactive input closed before answering: ${label}.`);
+        }
+        return answer.value;
     }
-    finally {
-        rl.close();
+    lineIterator() {
+        if (this.closed) {
+            throw new InteractiveCancelledError();
+        }
+        if (!this.rl || !this.lines) {
+            this.rl = createInterface({ input: this.input, terminal: false });
+            this.rl.on('SIGINT', () => this.rl?.close());
+            this.lines = this.rl[Symbol.asyncIterator]();
+        }
+        return this.lines;
+    }
+    releaseLineInput() {
+        this.rl?.close();
+        this.rl = undefined;
+        this.lines = undefined;
     }
 }
-export async function confirmDependencyInstallation(commands) {
-    const rl = createInterface({ input, output });
+async function withPrompter(dependencies, callback) {
+    const prompter = new InteractivePrompter(dependencies);
     try {
-        output.write('\nProject dependency commands:\n');
-        for (const command of commands) {
-            output.write(`- ${command.cwd}: ${formatCommand(command.command)}\n`);
-        }
-        output.write('\n');
-        return await confirm(rl, 'Install project-local dependencies now?', false);
+        return await callback(prompter);
     }
     finally {
-        rl.close();
+        prompter.close();
     }
 }
+export async function promptForInitOptions(initial, dependencies) {
+    return withPrompter(dependencies, (prompter) => prompter.promptForInitOptions(initial));
+}
+export async function confirmPlan(plan, yes, dependencies, actionLabel) {
+    return withPrompter(dependencies, (prompter) => prompter.confirmPlan(plan, yes, actionLabel));
+}
+export async function confirmToolInstallation(prompt, dependencies) {
+    return withPrompter(dependencies, (prompter) => prompter.confirmToolInstallation(prompt));
+}
+export async function confirmFileReplacements(paths, dependencies) {
+    return withPrompter(dependencies, (prompter) => prompter.confirmFileReplacements(paths));
+}
+export async function confirmDependencyInstallation(commands, dependencies) {
+    return withPrompter(dependencies, (prompter) => prompter.confirmDependencyInstallation(commands));
+}
 export function resolveCatalogInput(options) {
     return {
         ...options,