gsdd-cli 0.1.0 → 0.3.1

package/bin/gsdd.mjs

@@ -24,51 +24,61 @@ const __dirname = dirname(__filename);
 const DISTILLED_DIR = join(__dirname, '..', 'distilled');
 const AGENTS_DIR = join(__dirname, '..', 'agents');
 const CWD = process.cwd();
-const PLANNING_DIR = join(CWD, '.planning');
 const IS_MAIN = process.argv[1]
   ? realpathSync(process.argv[1]) === realpathSync(__filename)
   : false;
 
 const [,, command, ...args] = process.argv;
 
+function defineWorkflow({ mutatesArtifacts = true, ...workflow }) {
+  return {
+    ...workflow,
+    mutatesArtifacts,
+    agent: mutatesArtifacts ? 'Code' : 'Plan',
+    opencodeType: mutatesArtifacts ? 'edit' : 'plan',
+  };
+}
+
 const WORKFLOWS = [
-  { name: 'gsdd-new-project', workflow: 'new-project.md', description: 'New project - questioning, codebase audit, research, spec, roadmap', agent: 'Plan', opencodeType: 'plan' },
-  { name: 'gsdd-map-codebase', workflow: 'map-codebase.md', description: 'Map or refresh codebase - 4 parallel mappers, staleness check, secrets scan', agent: 'Plan', opencodeType: 'plan' },
-  { name: 'gsdd-plan', workflow: 'plan.md', description: 'Plan a phase - research check, backward planning, task creation', agent: 'Plan', opencodeType: 'plan' },
-  { name: 'gsdd-execute', workflow: 'execute.md', description: 'Execute a phase plan - implement tasks, verify changes, follow repo git conventions', agent: 'Code', opencodeType: 'edit' },
-  { name: 'gsdd-verify', workflow: 'verify.md', description: 'Verify a completed phase - 3-level checks, anti-pattern scan', agent: 'Plan', opencodeType: 'plan' },
-  { name: 'gsdd-audit-milestone', workflow: 'audit-milestone.md', description: 'Audit a completed milestone - cross-phase integration, requirements coverage, E2E flows', agent: 'Plan', opencodeType: 'plan' },
-  { name: 'gsdd-quick', workflow: 'quick.md', description: 'Quick task - plan and execute a sub-hour task outside the phase cycle', agent: 'Code', opencodeType: 'edit' },
-  { name: 'gsdd-pause', workflow: 'pause.md', description: 'Pause work - save session context for seamless resumption', agent: 'Plan', opencodeType: 'plan' },
-  { name: 'gsdd-resume', workflow: 'resume.md', description: 'Resume work - restore context and route to next action', agent: 'Plan', opencodeType: 'plan' },
-  { name: 'gsdd-progress', workflow: 'progress.md', description: 'Check progress - show project status and route to next action', agent: 'Plan', opencodeType: 'plan' },
+  defineWorkflow({ name: 'gsdd-new-project', workflow: 'new-project.md', description: 'New project - questioning, codebase audit, research, spec, roadmap' }),
+  defineWorkflow({ name: 'gsdd-map-codebase', workflow: 'map-codebase.md', description: 'Map or refresh codebase - 4 parallel mappers, staleness check, secrets scan' }),
+  defineWorkflow({ name: 'gsdd-plan', workflow: 'plan.md', description: 'Plan a phase - research check, backward planning, task creation' }),
+  defineWorkflow({ name: 'gsdd-execute', workflow: 'execute.md', description: 'Execute a phase plan - implement tasks, verify changes, follow repo git conventions' }),
+  defineWorkflow({ name: 'gsdd-verify', workflow: 'verify.md', description: 'Verify a completed phase - 3-level checks, anti-pattern scan' }),
+  defineWorkflow({ name: 'gsdd-audit-milestone', workflow: 'audit-milestone.md', description: 'Audit a completed milestone - cross-phase integration, requirements coverage, E2E flows' }),
+  defineWorkflow({ name: 'gsdd-quick', workflow: 'quick.md', description: 'Quick task - plan and execute a sub-hour task outside the phase cycle' }),
+  defineWorkflow({ name: 'gsdd-pause', workflow: 'pause.md', description: 'Pause work - save session context for seamless resumption' }),
+  defineWorkflow({ name: 'gsdd-resume', workflow: 'resume.md', description: 'Resume work - restore context and route to next action' }),
+  defineWorkflow({ name: 'gsdd-progress', workflow: 'progress.md', description: 'Check progress - show project status and route to next action', mutatesArtifacts: false }),
 ];
 
 const FRAMEWORK_VERSION = 'v1.2';
 
-const ADAPTERS = createAdapterRegistry({
-  cwd: CWD,
-  workflows: WORKFLOWS,
-  renderAgentsBoundedBlock,
-  renderAgentsFileContent,
-  renderOpenCodeCommandContent,
-  renderSkillContent,
-  upsertBoundedBlock,
-  getDelegateContent,
-  loadProjectModelConfig,
-  getRuntimeModelOverride,
-  resolveRuntimeAgentModel,
-});
+function createCliContext(cwd = process.cwd()) {
+  return {
+    cwd,
+    planningDir: join(cwd, '.planning'),
+    distilledDir: DISTILLED_DIR,
+    agentsDir: AGENTS_DIR,
+    workflows: WORKFLOWS,
+    frameworkVersion: FRAMEWORK_VERSION,
+    adapters: createAdapterRegistry({
+      cwd,
+      workflows: WORKFLOWS,
+      renderAgentsBoundedBlock,
+      renderAgentsFileContent,
+      renderOpenCodeCommandContent,
+      renderSkillContent,
+      upsertBoundedBlock,
+      getDelegateContent,
+      loadProjectModelConfig,
+      getRuntimeModelOverride,
+      resolveRuntimeAgentModel,
+    }),
+  };
+}
 
-const INIT_CONTEXT = {
-  cwd: CWD,
-  planningDir: PLANNING_DIR,
-  distilledDir: DISTILLED_DIR,
-  agentsDir: AGENTS_DIR,
-  workflows: WORKFLOWS,
-  frameworkVersion: FRAMEWORK_VERSION,
-  adapters: ADAPTERS,
-};
+const INIT_CONTEXT = createCliContext(CWD);
 
 const cmdInit = createCmdInit(INIT_CONTEXT);
 const cmdUpdate = createCmdUpdate(INIT_CONTEXT);
@@ -99,4 +109,4 @@ if (IS_MAIN) {
   await runCli();
 }
 
-export { cmdHelp, cmdInit, cmdUpdate, cmdModels, cmdHealth, cmdFindPhase, cmdVerify, cmdScaffold, runCli, FRAMEWORK_VERSION };
+export { cmdHelp, cmdInit, cmdUpdate, cmdModels, cmdHealth, cmdFindPhase, cmdVerify, cmdScaffold, runCli, FRAMEWORK_VERSION, createCliContext };

package/bin/lib/init-flow.mjs

@@ -0,0 +1,220 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync, cpSync } from 'fs';
+import { join, isAbsolute } from 'path';
+import { renderSkillContent } from './rendering.mjs';
+import { buildManifest, writeManifest } from './manifest.mjs';
+import { parseFlagValue, parseToolsFlag, parseAutoFlag } from './cli-utils.mjs';
+import { buildDefaultConfig } from './models.mjs';
+import { installProjectTemplates, refreshTemplates } from './templates.mjs';
+import {
+  detectPlatforms,
+  getAdaptersToUpdate,
+  getPostInitRoutingLines,
+  normalizeRequestedTools,
+  resolveAdapters,
+  resolveInteractiveInitSession,
+} from './init-runtime.mjs';
+import { createInitPromptApi } from './init-prompts.mjs';
+
+export function createCmdInit(ctx) {
+  return async function cmdInit(...initArgs) {
+    console.log('gsdd init - setting up SDD workflow\n');
+
+    const isAuto = parseAutoFlag(initArgs);
+    const toolsFlag = parseFlagValue(initArgs, '--tools');
+    const briefFlag = parseFlagValue(initArgs, '--brief');
+    let briefSource = null;
+
+    if (toolsFlag.invalid) {
+      console.error('ERROR: --tools requires a value. Example: gsdd init --tools claude');
+      process.exitCode = 1;
+      return;
+    }
+
+    if (briefFlag.invalid) {
+      console.error('ERROR: --brief requires a file path. Example: gsdd init --brief project-idea.md');
+      process.exitCode = 1;
+      return;
+    }
+
+    if (briefFlag.value) {
+      briefSource = isAbsolute(briefFlag.value) ? briefFlag.value : join(ctx.cwd, briefFlag.value);
+      if (!existsSync(briefSource)) {
+        console.error(`ERROR: Brief file not found: ${briefFlag.value}`);
+        process.exitCode = 1;
+        return;
+      }
+    }
+
+    const parsedTools = parseToolsFlag(initArgs);
+    if (isAuto && parsedTools.length === 0) {
+      console.error('ERROR: --auto requires --tools <platform>. Example: gsdd init --auto --tools claude');
+      process.exitCode = 1;
+      return;
+    }
+
+    const promptApi = ctx.initPromptApi || createInitPromptApi();
+    const interactiveSession = await resolveInteractiveInitSession({
+      ctx,
+      promptApi,
+      parsedTools,
+      isAuto,
+    });
+
+    const existed = existsSync(ctx.planningDir);
+    mkdirSync(join(ctx.planningDir, 'phases'), { recursive: true });
+    mkdirSync(join(ctx.planningDir, 'research'), { recursive: true });
+    console.log(existed
+      ? '  - .planning/ already exists (ensured subdirectories)'
+      : '  - created .planning/ directory structure');
+
+    installProjectTemplates(ctx);
+    await ensureConfig({
+      cwd: ctx.cwd,
+      planningDir: ctx.planningDir,
+      isAuto,
+      promptApi,
+      preselectedConfig: interactiveSession.config,
+    });
+
+    if (briefSource) {
+      cpSync(briefSource, join(ctx.planningDir, 'PROJECT_BRIEF.md'));
+      console.log('  - copied project brief to .planning/PROJECT_BRIEF.md');
+    }
+
+    generateOpenStandardSkills(ctx.cwd, ctx.workflows);
+    console.log('  - generated open-standard skills (.agents/skills/gsdd-*)');
+
+    for (const adapter of resolveAdapters(ctx.adapters, interactiveSession.adapterTargets)) {
+      adapter.generate();
+      console.log(`  - ${adapter.summary('generated')}`);
+    }
+
+    const manifest = buildManifest({ planningDir: ctx.planningDir, frameworkVersion: ctx.frameworkVersion });
+    writeManifest(ctx.planningDir, manifest);
+    console.log('  - wrote generation manifest');
+
+    console.log('\nSDD initialized.');
+    console.log('Next: run the new-project workflow to produce SPEC.md and ROADMAP.md:\n');
+    printPostInitRouting(interactiveSession.selectedRuntimes);
+  };
+}
+
+export function createCmdUpdate(ctx) {
+  return function cmdUpdate(...updateArgs) {
+    const isDry = updateArgs.includes('--dry');
+    const doTemplates = updateArgs.includes('--templates');
+
+    console.log(`gsdd update - regenerating adapter files${isDry ? ' (dry run)' : ''}\n`);
+
+    const parsedTools = parseToolsFlag(updateArgs);
+    const requested = normalizeRequestedTools(parsedTools);
+    const platforms = parsedTools.length > 0 ? requested.adapterTargets : detectPlatforms(ctx.adapters);
+
+    let updated = false;
+
+    if (doTemplates) {
+      refreshTemplates({ ...ctx, isDry });
+      updated = true;
+    }
+
+    if (platforms.length > 0 || existsSync(join(ctx.cwd, '.agents', 'skills'))) {
+      if (isDry) {
+        console.log('  - would update open-standard skills (.agents/skills/gsdd-*)');
+      } else {
+        generateOpenStandardSkills(ctx.cwd, ctx.workflows);
+        console.log('  - updated open-standard skills (.agents/skills/gsdd-*)');
+      }
+      updated = true;
+    }
+
+    for (const adapter of getAdaptersToUpdate(ctx.adapters, platforms)) {
+      if (isDry) {
+        console.log(`  - would update ${adapter.name} adapter`);
+      } else {
+        adapter.generate();
+        console.log(`  - ${adapter.summary('updated')}`);
+      }
+      updated = true;
+    }
+
+    if (!updated) {
+      console.log('  - no adapters found to update (run `gsdd init` first)');
+    } else if (isDry) {
+      console.log('\nDry run complete. No files were written.\n');
+    } else {
+      if (doTemplates && existsSync(ctx.planningDir)) {
+        const manifest = buildManifest({ planningDir: ctx.planningDir, frameworkVersion: ctx.frameworkVersion });
+        writeManifest(ctx.planningDir, manifest);
+        console.log('  - updated generation manifest');
+      }
+      console.log('\nAdapters updated.\n');
+    }
+  };
+}
+
+function generateOpenStandardSkills(cwd, workflows) {
+  for (const workflow of workflows) {
+    const dir = join(cwd, '.agents', 'skills', workflow.name);
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, 'SKILL.md'), renderSkillContent(workflow));
+  }
+}
+
+async function ensureConfig({ cwd, planningDir, isAuto, promptApi, preselectedConfig = null }) {
+  const configFile = join(planningDir, 'config.json');
+  if (existsSync(configFile)) {
+    console.log('  - .planning/config.json already exists');
+    return;
+  }
+
+  if (preselectedConfig) {
+    writeFileSync(configFile, JSON.stringify(preselectedConfig, null, 2));
+    console.log('  - saved .planning/config.json (guided wizard)\n');
+    if (!preselectedConfig.commitDocs) ensureGitignoreEntry(cwd);
+    return;
+  }
+
+  if (isAuto) {
+    console.log('  - auto mode: writing config.json with defaults');
+    writeFileSync(configFile, JSON.stringify(buildDefaultConfig({ autoAdvance: true }), null, 2));
+    console.log('  - saved .planning/config.json (auto mode - autoAdvance enabled)\n');
+    return;
+  }
+
+  if (!process.stdin.isTTY) {
+    console.log('  - non-interactive mode detected: writing config.json with defaults');
+    writeFileSync(configFile, JSON.stringify(buildDefaultConfig(), null, 2));
+    console.log('  - saved .planning/config.json (defaults - re-run gsdd init in a terminal to customize)\n');
+    return;
+  }
+
+  const config = await promptApi.promptForConfig(cwd);
+  writeFileSync(configFile, JSON.stringify(config, null, 2));
+  console.log('  - saved .planning/config.json (guided wizard)\n');
+
+  if (!config.commitDocs) ensureGitignoreEntry(cwd);
+}
+
+function ensureGitignoreEntry(cwd) {
+  const gitignorePath = join(cwd, '.gitignore');
+  const ignoreEntry = '\n# GSDD planning docs (local only)\n.planning/\n';
+
+  if (existsSync(gitignorePath)) {
+    const existing = readFileSync(gitignorePath, 'utf-8');
+    if (!existing.includes('.planning/')) {
+      writeFileSync(gitignorePath, existing + ignoreEntry);
+      console.log('  - added .planning/ to .gitignore');
+    }
+    return;
+  }
+
+  writeFileSync(gitignorePath, ignoreEntry.trimStart());
+  console.log('  - created .gitignore with .planning/ entry');
+}
+
+function printPostInitRouting(selectedRuntimes) {
+  for (const line of getPostInitRoutingLines(selectedRuntimes)) {
+    console.log(line);
+  }
+  console.log('');
+}

package/bin/lib/init-prompts.mjs

@@ -0,0 +1,308 @@
+import * as readline from 'readline';
+import { DEFAULT_GIT_PROTOCOL, normalizeModelProfile } from './models.mjs';
+import { buildRuntimeChoices, INIT_VERSION, resolveWizardAdapterTargets } from './init-runtime.mjs';
+
+const ANSI = {
+  reset: '\x1b[0m',
+  dim: '\x1b[2m',
+  bold: '\x1b[1m',
+  cyan: '\x1b[36m',
+  green: '\x1b[32m',
+};
+
+export function createInitPromptApi({ input = process.stdin, output = process.stdout } = {}) {
+  return {
+    async runInitWizard({ cwd, adapters }) {
+      output.write(`${ANSI.bold}${ANSI.cyan}GSDD Install Wizard${ANSI.reset}\n`);
+      output.write(`${ANSI.dim}Portable skills are always installed. Select the runtimes you want GSDD to feel native in.${ANSI.reset}\n\n`);
+
+      const runtimeChoices = buildRuntimeChoices(adapters);
+      const selectedRuntimes = await promptMultiSelect({
+        input,
+        output,
+        title: 'Step 1 of 3 - Select runtimes',
+        hint: 'Space toggles, Enter confirms.',
+        choices: runtimeChoices,
+      });
+      const installGovernance = await promptConfirm({
+        input,
+        output,
+        title: 'Step 2 of 3 - Repo-wide AGENTS.md governance',
+        prompt: 'Install repo-wide AGENTS.md rules?',
+        defaultValue: false,
+        details: [
+          'Why care: consistent behavioral discipline across sessions and mixed-runtime teams.',
+          'Why skip it: it writes to the repo root, and your selected runtimes already discover .agents/skills/ natively.',
+        ],
+      });
+      const config = await promptForConfig(cwd, { input, output });
+      return {
+        selectedRuntimes,
+        adapterTargets: resolveWizardAdapterTargets(selectedRuntimes, installGovernance),
+        config,
+      };
+    },
+    promptForConfig(cwd) {
+      return promptForConfig(cwd, { input, output });
+    },
+  };
+}
+
+export async function promptForConfig(cwd, { input = process.stdin, output = process.stdout } = {}) {
+  output.write(`\n${ANSI.bold}Step 3 of 3 - Configure planning defaults${ANSI.reset}\n`);
+
+  const researchDepth = await promptSingleSelect({
+    input,
+    output,
+    title: 'Research depth',
+    choices: [
+      { value: 'balanced', label: 'balanced', description: 'SOTA research per phase (recommended)' },
+      { value: 'fast', label: 'fast', description: 'Skip deeper domain research and plan from current context' },
+      { value: 'deep', label: 'deep', description: 'Exhaustive research sweeps and parallel researchers' },
+    ],
+    defaultIndex: 0,
+  });
+  const parallelization = await promptSingleSelect({
+    input,
+    output,
+    title: 'Parallelization',
+    choices: yesNoChoices('Run independent agents in parallel?', true),
+    defaultIndex: 0,
+  });
+  const commitDocs = await promptSingleSelect({
+    input,
+    output,
+    title: 'Planning docs in git',
+    choices: yesNoChoices('Track .planning/ in git?', true),
+    defaultIndex: 0,
+  });
+  const modelProfile = await promptSingleSelect({
+    input,
+    output,
+    title: 'Model profile',
+    choices: [
+      { value: 'balanced', label: 'balanced', description: 'Capable default for most agents (recommended)' },
+      { value: 'quality', label: 'quality', description: 'Most capable model for research and roadmap work' },
+      { value: 'budget', label: 'budget', description: 'Cheapest and fastest model profile' },
+    ],
+    defaultIndex: 0,
+  });
+  const workflowResearch = await promptSingleSelect({
+    input,
+    output,
+    title: 'Workflow research',
+    choices: yesNoChoices('Research before planning each phase?', true),
+    defaultIndex: 0,
+  });
+  const workflowDiscuss = await promptSingleSelect({
+    input,
+    output,
+    title: 'Approach discussion',
+    choices: yesNoChoices('Explore approaches with the user before planning?', false),
+    defaultIndex: 0,
+  });
+  const workflowPlanCheck = await promptSingleSelect({
+    input,
+    output,
+    title: 'Plan checking',
+    choices: yesNoChoices('Run the fresh-context plan checker before execution?', true),
+    defaultIndex: 0,
+  });
+  const workflowVerifier = await promptSingleSelect({
+    input,
+    output,
+    title: 'Phase verification',
+    choices: yesNoChoices('Run phase verification after execution?', true),
+    defaultIndex: 0,
+  });
+
+  const gitProtocol = await promptGitProtocol(cwd, { input, output });
+
+  return {
+    researchDepth,
+    parallelization,
+    commitDocs,
+    modelProfile: normalizeModelProfile(modelProfile),
+    workflow: {
+      research: workflowResearch,
+      discuss: workflowDiscuss,
+      planCheck: workflowPlanCheck,
+      verifier: workflowVerifier,
+    },
+    gitProtocol,
+    initVersion: INIT_VERSION,
+  };
+}
+
+export async function promptGitProtocol(cwd, { input = process.stdin, output = process.stdout } = {}) {
+  if (typeof input.resume === 'function') input.resume();
+  output.write(`\n${ANSI.bold}Version control guidance${ANSI.reset}\n`);
+  output.write(`${ANSI.dim}This is advisory only. Repo or user conventions still win.${ANSI.reset}\n`);
+  const rl = readline.createInterface({ input, output });
+  const askQuestion = (query) => new Promise((resolve) => rl.question(query, resolve));
+
+  try {
+    let branch = await askQuestion('  Branching guidance (Enter for default): ');
+    branch = branch.trim() || DEFAULT_GIT_PROTOCOL.branch;
+
+    let commit = await askQuestion('  Commit guidance (Enter for default): ');
+    commit = commit.trim() || DEFAULT_GIT_PROTOCOL.commit;
+
+    let pr = await askQuestion('  PR guidance (Enter for default): ');
+    pr = pr.trim() || DEFAULT_GIT_PROTOCOL.pr;
+
+    return { branch, commit, pr };
+  } finally {
+    rl.close();
+  }
+}
+
+export function yesNoChoices(prompt, defaultYes) {
+  return [
+    { value: true, label: 'yes', description: `${prompt} Yes.` },
+    { value: false, label: 'no', description: `${prompt} No.` },
+  ].sort((a, b) => {
+    if (defaultYes) return a.value === true ? -1 : 1;
+    return a.value === false ? -1 : 1;
+  });
+}
+
+export async function promptConfirm({ input, output, title, prompt, defaultValue, details = [] }) {
+  if (typeof input.resume === 'function') input.resume();
+  output.write(`\n${ANSI.bold}${title}${ANSI.reset}\n`);
+  for (const detail of details) {
+    output.write(`  ${ANSI.dim}${detail}${ANSI.reset}\n`);
+  }
+  const rl = readline.createInterface({ input, output });
+  const suffix = defaultValue ? '[Y/n]' : '[y/N]';
+  try {
+    const answer = await new Promise((resolve) => rl.question(`  ${prompt} ${suffix}: `, resolve));
+    const normalized = answer.trim().toLowerCase();
+    if (!normalized) return defaultValue;
+    return normalized === 'y' || normalized === 'yes';
+  } finally {
+    rl.close();
+  }
+}
+
+export async function promptSingleSelect({ input, output, title, choices, defaultIndex = 0 }) {
+  const selected = await promptChoiceList({
+    input,
+    output,
+    title,
+    choices: choices.map((choice, index) => ({
+      ...choice,
+      selected: index === defaultIndex,
+      detected: false,
+    })),
+    multi: false,
+  });
+  return selected[0];
+}
+
+export async function promptMultiSelect({ input, output, title, hint, choices }) {
+  return promptChoiceList({ input, output, title, hint, choices, multi: true });
+}
+
+export async function promptChoiceList({ input, output, title, hint = 'Use arrows to move. Enter confirms.', choices, multi }) {
+  if (typeof input.resume === 'function') input.resume();
+  readline.emitKeypressEvents(input);
+  const previousRawMode = typeof input.isRaw === 'boolean' ? input.isRaw : false;
+  if (typeof input.setRawMode === 'function') input.setRawMode(true);
+
+  let cursor = Math.max(0, choices.findIndex((choice) => choice.selected));
+  let renderedLines = 0;
+
+  const selectCursor = () => {
+    if (multi) return;
+    for (const choice of choices) choice.selected = false;
+    choices[cursor].selected = true;
+  };
+
+  const measureLines = (text) => {
+    const columns = Math.max(20, Number(output.columns) || 80);
+    const visible = stripAnsi(text);
+    return visible.split('\n').reduce((total, line) => {
+      const width = Math.max(1, line.length);
+      return total + Math.ceil(width / columns);
+    }, 0);
+  };
+
+  const render = () => {
+    if (renderedLines > 0) {
+      readline.moveCursor(output, 0, -renderedLines);
+    }
+    readline.cursorTo(output, 0);
+    readline.clearScreenDown(output);
+    const lines = [`${ANSI.bold}${title}${ANSI.reset}`];
+    if (hint) lines.push(`${ANSI.dim}${hint}${ANSI.reset}`);
+    lines.push('');
+    for (let i = 0; i < choices.length; i++) {
+      const choice = choices[i];
+      const pointer = i === cursor ? `${ANSI.green}>${ANSI.reset}` : ' ';
+      const mark = choice.selected ? `${ANSI.green}[x]${ANSI.reset}` : '[ ]';
+      const detected = choice.detected ? ` ${ANSI.dim}(detected)${ANSI.reset}` : '';
+      lines.push(`${pointer} ${mark} ${choice.label}${detected}`);
+      lines.push(`    ${ANSI.dim}${choice.description}${ANSI.reset}`);
+    }
+
+    renderedLines = 0;
+    for (const line of lines) {
+      output.write(`${line}\n`);
+      renderedLines += measureLines(line);
+    }
+  };
+
+  render();
+
+  const values = await new Promise((resolve, reject) => {
+    const cleanup = () => {
+      input.off('keypress', onKeypress);
+      if (typeof input.setRawMode === 'function') input.setRawMode(previousRawMode);
+    };
+
+    const onKeypress = (_, key = {}) => {
+      if (key.ctrl && key.name === 'c') {
+        cleanup();
+        reject(new Error('Prompt cancelled by user'));
+        return;
+      }
+      if (key.name === 'up') {
+        cursor = cursor === 0 ? choices.length - 1 : cursor - 1;
+        selectCursor();
+        render();
+        return;
+      }
+      if (key.name === 'down') {
+        cursor = cursor === choices.length - 1 ? 0 : cursor + 1;
+        selectCursor();
+        render();
+        return;
+      }
+      if (key.name === 'space') {
+        if (multi) {
+          choices[cursor].selected = !choices[cursor].selected;
+        } else {
+          for (const choice of choices) choice.selected = false;
+          choices[cursor].selected = true;
+        }
+        render();
+        return;
+      }
+      if (key.name === 'return') {
+        selectCursor();
+        cleanup();
+        resolve(choices.filter((choice) => choice.selected).map((choice) => choice.value ?? choice.id));
+      }
+    };
+
+    input.on('keypress', onKeypress);
+  });
+
+  output.write('\n');
+  return values;
+}
+
+export function stripAnsi(text) {
+  return String(text).replace(/\x1B\[[0-9;]*[A-Za-z]/g, '');
+}