grimoire-wizard 0.5.1 → 0.6.0

package/dist/cli.js

@@ -56,6 +56,11 @@ var separatorOptionSchema = z.object({
   separator: z.string()
 });
 var selectChoiceSchema = z.union([selectOptionSchema, separatorOptionSchema]);
+var stepReviewConfigSchema = z.object({
+  hide: z.boolean().optional(),
+  label: z.string().optional(),
+  format: z.enum(["none", "uppercase", "lowercase", "capitalize"]).optional()
+}).optional();
 var baseStepFields = {
   id: z.string(),
   message: z.string(),
@@ -64,7 +69,8 @@ var baseStepFields = {
   when: conditionSchema.optional(),
   keepValuesOnPrevious: z.boolean().optional(),
   required: z.boolean().optional(),
-  group: z.string().optional()
+  group: z.string().optional(),
+  review: stepReviewConfigSchema
 };
 var textStepSchema = z.object({
   ...baseStepFields,
@@ -81,7 +87,8 @@ var selectStepSchema = z.object({
   default: z.string().optional(),
   routes: z.record(z.string(), z.string()).optional(),
   pageSize: z.number().int().positive().optional(),
-  loop: z.boolean().optional()
+  loop: z.boolean().optional(),
+  columns: z.number().int().min(1).max(8).optional()
 });
 var multiSelectStepSchema = z.object({
   ...baseStepFields,
@@ -92,7 +99,8 @@ var multiSelectStepSchema = z.object({
   min: z.number().int().nonnegative().optional(),
   max: z.number().int().positive().optional(),
   pageSize: z.number().int().positive().optional(),
-  loop: z.boolean().optional()
+  loop: z.boolean().optional(),
+  columns: z.number().int().min(1).max(8).optional()
 });
 var confirmStepSchema = z.object({
   ...baseStepFields,
@@ -120,7 +128,8 @@ var searchStepSchema = z.object({
   default: z.string().optional(),
   placeholder: z.string().optional(),
   pageSize: z.number().int().positive().optional(),
-  loop: z.boolean().optional()
+  loop: z.boolean().optional(),
+  columns: z.number().int().min(1).max(8).optional()
 });
 var editorStepSchema = z.object({
   ...baseStepFields,
@@ -148,7 +157,14 @@ var messageStepSchema = z.object({
 });
 var noteStepSchema = z.object({
   ...baseStepFields,
-  type: z.literal("note")
+  type: z.literal("note"),
+  style: z.enum(["info", "warning", "error", "success", "code", "banner"]).optional()
+});
+var browserStepSchema = z.object({
+  ...baseStepFields,
+  type: z.literal("browser"),
+  url: z.string(),
+  fallback: z.string().optional()
 });
 var stepConfigSchema = z.discriminatedUnion("type", [
   textStepSchema,
@@ -162,12 +178,19 @@ var stepConfigSchema = z.discriminatedUnion("type", [
   pathStepSchema,
   toggleStepSchema,
   messageStepSchema,
-  noteStepSchema
+  noteStepSchema,
+  browserStepSchema
 ]);
 var hexColorSchema = z.string().regex(
   /^#[0-9a-fA-F]{6}$/,
   "Must be a 6-digit hex color (e.g., #FF0000)"
 );
+var progressBarConfigSchema = z.object({
+  width: z.number().int().positive().max(200).optional(),
+  filledColor: hexColorSchema.optional(),
+  emptyColor: hexColorSchema.optional(),
+  style: z.enum(["blocks", "line", "dots", "arrow"]).optional()
+}).optional();
 var themeConfigSchema = z.object({
   preset: z.enum(["default", "catppuccin", "dracula", "nord", "tokyonight", "monokai"]).optional(),
   tokens: z.object({
@@ -177,7 +200,12 @@ var themeConfigSchema = z.object({
     warning: hexColorSchema.optional(),
     info: hexColorSchema.optional(),
     muted: hexColorSchema.optional(),
-    accent: hexColorSchema.optional()
+    accent: hexColorSchema.optional(),
+    highlight: hexColorSchema.optional(),
+    highlightBg: hexColorSchema.optional(),
+    pointer: hexColorSchema.optional(),
+    checked: hexColorSchema.optional(),
+    dimmed: hexColorSchema.optional()
   }).optional(),
   icons: z.object({
     step: z.string().optional(),
@@ -191,12 +219,15 @@ var themeConfigSchema = z.object({
       frames: z.array(z.string()).min(1),
       interval: z.number().positive().optional()
     })
-  ]).optional()
+  ]).optional(),
+  spinnerElapsed: z.boolean().optional(),
+  progressBar: progressBarConfigSchema
 });
 var preFlightCheckSchema = z.object({
   name: z.string(),
   run: z.string(),
-  message: z.string()
+  message: z.string(),
+  showOutput: z.boolean().optional()
 });
 var actionConfigSchema = z.object({
   name: z.string().optional(),
@@ -209,7 +240,13 @@ var wizardConfigSchema = z.object({
     version: z.string().optional(),
     description: z.string().optional(),
     review: z.boolean().optional(),
-    icon: z.string().optional()
+    icon: z.string().optional(),
+    iconSize: z.union([z.enum(["small", "medium", "large"]), z.number().int().positive()]).optional(),
+    font: z.string().min(1).optional(),
+    banner: z.union([z.string(), z.function()]).optional(),
+    subtitle: z.string().optional(),
+    clearBetweenSteps: z.boolean().optional(),
+    checksStyle: z.enum(["spinner", "tasklist"]).optional()
   }),
   theme: themeConfigSchema.optional(),
   steps: z.array(stepConfigSchema).min(1),
@@ -490,11 +527,12 @@ async function loadWithInheritance(filePath, seen) {
 async function loadWizardConfig(filePath) {
   const config = await loadWithInheritance(filePath, /* @__PURE__ */ new Set());
   detectCycles(config);
+  config._configFilePath = resolve(filePath);
   return config;
 }
 
 // src/runner.ts
-import { execSync } from "child_process";
+import { execSync, execFileSync } from "child_process";
 import { resolve as resolve2, dirname as dirname2 } from "path";
 import { pathToFileURL } from "url";
 
@@ -671,7 +709,8 @@ function wizardReducer(state, transition, config) {
           errors: { ...state.errors, [state.currentStepId]: validationError }
         };
       }
-      const updatedAnswers = {
+      const isDisplayOnly = currentStep.type === "note" || currentStep.type === "message" || currentStep.type === "browser";
+      const updatedAnswers = isDisplayOnly ? { ...state.answers } : {
         ...state.answers,
         [state.currentStepId]: transition.value
       };
@@ -879,7 +918,12 @@ var DEFAULT_TOKENS = {
   warning: "#FFD93D",
   info: "#4D96FF",
   muted: "#888888",
-  accent: "#C084FC"
+  accent: "#C084FC",
+  highlight: "#5B9BD5",
+  highlightBg: "#1E1E2E",
+  pointer: "#C084FC",
+  checked: "#6BCB77",
+  dimmed: "#555555"
 };
 var DEFAULT_ICONS = {
   step: "\u25CF",
@@ -887,6 +931,25 @@ var DEFAULT_ICONS = {
   stepPending: "\u25CB",
   pointer: "\u203A"
 };
+var PROGRESS_BAR_CHARS = {
+  blocks: { filled: "\u2588", empty: "\u2591" },
+  line: { filled: "\u2500", empty: "\u2500" },
+  dots: { filled: "\u2022", empty: "\xB7" },
+  arrow: { filled: "\u2550", empty: "\u2500" }
+};
+function resolveProgressBar(config, tokens) {
+  const style = config?.style ?? "blocks";
+  const chars = PROGRESS_BAR_CHARS[style];
+  const filledHex = config?.filledColor ?? tokens?.success ?? DEFAULT_TOKENS.success;
+  const emptyHex = config?.emptyColor ?? tokens?.muted ?? DEFAULT_TOKENS.muted;
+  return {
+    width: config?.width ?? 20,
+    filledColor: chalk.hex(filledHex),
+    emptyColor: chalk.hex(emptyHex),
+    style,
+    chars
+  };
+}
 function resolveTheme(themeConfig) {
   const presetTokens = themeConfig?.preset ? THEME_PRESETS[themeConfig.preset] : void 0;
   const tokens = { ...DEFAULT_TOKENS, ...presetTokens, ...themeConfig?.tokens };
@@ -899,9 +962,16 @@ function resolveTheme(themeConfig) {
     info: chalk.hex(tokens.info),
     muted: chalk.hex(tokens.muted),
     accent: chalk.hex(tokens.accent),
+    highlight: chalk.hex(tokens.highlight),
+    highlightBg: chalk.bgHex(tokens.highlightBg),
+    pointer: chalk.hex(tokens.pointer),
+    checked: chalk.hex(tokens.checked),
+    dimmed: chalk.hex(tokens.dimmed),
     bold: chalk.bold,
     icons,
-    spinner: resolveSpinner(themeConfig?.spinner)
+    spinner: resolveSpinner(themeConfig?.spinner),
+    spinnerElapsed: themeConfig?.spinnerElapsed ?? false,
+    progressBar: resolveProgressBar(themeConfig?.progressBar, tokens)
   };
 }
 
@@ -919,11 +989,11 @@ import {
 } from "@inquirer/prompts";
 var InquirerRenderer = class {
   renderStepHeader(stepIndex, totalVisible, message, theme, description) {
-    const barWidth = 20;
-    const filledCount = totalVisible > 0 ? Math.round(stepIndex / totalVisible * barWidth) : 0;
-    const remainingCount = barWidth - filledCount;
-    const filledBar = theme.success("\u2588".repeat(filledCount));
-    const remainingBar = theme.muted("\u2591".repeat(remainingCount));
+    const pb = theme.progressBar;
+    const filledCount = totalVisible > 0 ? Math.round(stepIndex / totalVisible * pb.width) : 0;
+    const remainingCount = pb.width - filledCount;
+    const filledBar = pb.filledColor(pb.chars.filled.repeat(filledCount));
+    const remainingBar = pb.emptyColor(pb.chars.empty.repeat(remainingCount));
     const counter = theme.muted(`Step ${String(stepIndex + 1)}/${String(totalVisible)}`);
     const stepMessage = theme.muted(`\u2014 ${message}`);
     console.log(`
@@ -932,6 +1002,39 @@ var InquirerRenderer = class {
       console.log(`  ${theme.muted(description)}`);
     }
   }
+  renderNote(step, theme) {
+    const title = step.message;
+    const body = step.description ?? "";
+    const style = step.style ?? "info";
+    const { colorFn, icon } = getNoteStyleConfig(style, theme);
+    if (style === "banner") {
+      const width = Math.max(4, (process.stdout.columns ?? 60) - 4);
+      const rule = colorFn("\u2500".repeat(width));
+      console.log();
+      console.log(`  ${rule}`);
+      console.log(`  ${colorFn(icon)}  ${theme.bold(title)}`);
+      if (body) console.log(`  ${theme.muted(body)}`);
+      console.log(`  ${rule}`);
+      console.log();
+      return;
+    }
+    const border = colorFn("\u2502");
+    const topRule = colorFn(`\u250C${"\u2500".repeat(2)}`);
+    const bottomRule = colorFn(`\u2514${"\u2500".repeat(2)}`);
+    console.log();
+    console.log(`  ${topRule} ${colorFn(icon)} ${theme.bold(title)}`);
+    if (body) {
+      for (const line of body.split("\n")) {
+        if (style === "code") {
+          console.log(`  ${border}   ${theme.muted(line)}`);
+        } else {
+          console.log(`  ${border}   ${line}`);
+        }
+      }
+    }
+    console.log(`  ${bottomRule}`);
+    console.log();
+  }
   async renderText(step, state, theme) {
     const existingAnswer = state.answers[step.id];
     const defaultValue = typeof existingAnswer === "string" ? existingAnswer : step.default;
@@ -944,7 +1047,7 @@ var InquirerRenderer = class {
   async renderSelect(step, state, theme) {
     const existingAnswer = state.answers[step.id];
     const defaultValue = typeof existingAnswer === "string" ? existingAnswer : step.default;
-    const choices = step.options.map((opt) => {
+    const rawChoices = step.options.map((opt) => {
       if ("separator" in opt) {
         return new Separator(opt.separator);
       }
@@ -955,19 +1058,27 @@ var InquirerRenderer = class {
         disabled: opt.disabled
       };
     });
+    const itemChoices = rawChoices.filter((c) => !(c instanceof Separator));
+    const columnedItems = step.columns ? applyColumns(itemChoices, step.columns) : itemChoices;
+    let itemIdx = 0;
+    const choices = rawChoices.map((c) => c instanceof Separator ? c : columnedItems[itemIdx++] ?? c);
     return select({
       message: step.message,
       choices,
       default: defaultValue,
       pageSize: step.pageSize,
       loop: step.loop,
-      theme: { prefix: { idle: theme.icons.pointer, done: theme.icons.stepDone } }
+      theme: {
+        prefix: { idle: theme.icons.pointer, done: theme.icons.stepDone },
+        icon: { cursor: theme.icons.pointer },
+        style: { disabled: theme.dimmed }
+      }
     });
   }
   async renderMultiSelect(step, state, theme) {
     const existingAnswer = state.answers[step.id];
     const previousSelections = Array.isArray(existingAnswer) ? existingAnswer.filter((v) => typeof v === "string") : step.default;
-    const choices = step.options.map((opt) => {
+    const rawChoices = step.options.map((opt) => {
       if ("separator" in opt) {
         return new Separator(opt.separator);
       }
@@ -978,12 +1089,20 @@ var InquirerRenderer = class {
         disabled: opt.disabled
       };
     });
+    const itemChoices = rawChoices.filter((c) => !(c instanceof Separator));
+    const columnedItems = step.columns ? applyColumns(itemChoices, step.columns) : itemChoices;
+    let itemIdx = 0;
+    const choices = rawChoices.map((c) => c instanceof Separator ? c : columnedItems[itemIdx++] ?? c);
     return checkbox({
       message: step.message,
       choices,
       pageSize: step.pageSize,
       loop: step.loop,
-      theme: { prefix: { idle: theme.icons.pointer, done: theme.icons.stepDone } }
+      theme: {
+        prefix: { idle: theme.icons.pointer, done: theme.icons.stepDone },
+        icon: { cursor: theme.icons.pointer, checked: theme.checked("\u2714"), unchecked: theme.muted("\u25CB") },
+        style: { disabledChoice: theme.dimmed }
+      }
     });
   }
   async renderConfirm(step, state, theme) {
@@ -1015,15 +1134,17 @@ var InquirerRenderer = class {
     return result ?? defaultValue ?? 0;
   }
   async renderSearch(step, _state, theme) {
+    const message = step.placeholder ? `${step.message} ${theme.muted(`(${step.placeholder})`)}` : step.message;
     return search({
-      message: step.message,
+      message,
       source: (input4) => {
         const term = (input4 ?? "").toLowerCase();
-        return step.options.filter((opt) => "value" in opt).filter((opt) => !opt.disabled && opt.label.toLowerCase().includes(term)).map((opt) => ({
+        const filtered = step.options.filter((opt) => "value" in opt).filter((opt) => !opt.disabled && opt.label.toLowerCase().includes(term)).map((opt) => ({
           name: opt.label,
           value: opt.value,
           description: opt.hint
         }));
+        return step.columns ? applyColumns(filtered, step.columns) : filtered;
       },
       pageSize: step.pageSize,
       theme: { prefix: { idle: theme.icons.pointer, done: theme.icons.stepDone } }
@@ -1091,6 +1212,42 @@ ${theme.muted("\u2500".repeat(40))}`);
     process.stdout.write("\x1B[2J\x1B[0f");
   }
 };
+var NOTE_STYLE_MAP = {
+  info: { tokenKey: "info", icon: "\u2139" },
+  warning: { tokenKey: "warning", icon: "\u26A0" },
+  error: { tokenKey: "error", icon: "\u2716" },
+  success: { tokenKey: "success", icon: "\u2714" },
+  code: { tokenKey: "muted", icon: "\u276F" },
+  banner: { tokenKey: "primary", icon: "\u2605" }
+};
+function getNoteStyleConfig(style, theme) {
+  const entry = NOTE_STYLE_MAP[style];
+  return {
+    colorFn: theme[entry.tokenKey],
+    icon: entry.icon
+  };
+}
+function applyColumns(items, columns) {
+  const cols = Math.max(1, Math.floor(columns));
+  if (cols <= 1) return items;
+  if (items.length === 0) return items;
+  const maxLabel = Math.max(...items.map((i) => i.name.length));
+  const colWidth = maxLabel + 4;
+  const grouped = [];
+  for (let i = 0; i < items.length; i += cols) {
+    grouped.push(items.slice(i, i + cols));
+  }
+  const result = [];
+  for (const row of grouped) {
+    for (let c = 0; c < row.length; c++) {
+      const item = row[c];
+      const isLast = c === row.length - 1;
+      const paddedName = isLast ? item.name : item.name.padEnd(colWidth);
+      result.push({ ...item, name: paddedName });
+    }
+  }
+  return result;
+}
 
 // src/resolve.ts
 function resolveEnvDefault(value) {
@@ -1145,19 +1302,71 @@ function renderBanner(name, theme, options) {
   const icon = options?.icon;
   const prefix = icon ? `${icon}  ` : "";
   if (options?.plain) {
-    return `  ${prefix}${theme.bold(name)}`;
+    const line = `  ${prefix}${theme.bold(name)}`;
+    return options?.subtitle ? `${line}
+  ${theme.muted(options.subtitle)}` : line;
+  }
+  if (options?.banner) {
+    const bannerStr = (typeof options.banner === "function" ? options.banner(theme) : options.banner).replace(/\n$/, "");
+    const raw = bannerStr.split("\n");
+    const mid = Math.floor(raw.length / 2);
+    const bannerLines = raw.map((l, i) => {
+      if (icon && i === mid) return `  ${icon}  ${l}`;
+      return icon ? `      ${l}` : `  ${l}`;
+    }).join("\n");
+    const colored = typeof options.banner === "function" ? bannerLines : GRIMOIRE_GRADIENT(bannerLines);
+    return options?.subtitle ? `${colored}
+  ${theme.muted(options.subtitle)}` : colored;
   }
   try {
-    const art = figlet.textSync(name, {
-      font: "Small",
-      horizontalLayout: "default"
-    });
-    const lines = art.split("\n").map((line) => `  ${line}`).join("\n");
-    const banner = GRIMOIRE_GRADIENT(lines);
-    return icon ? `  ${icon}
-${banner}` : banner;
+    const requestedFont = options?.font ?? "Small";
+    let art;
+    try {
+      art = figlet.textSync(name, { font: requestedFont, horizontalLayout: "default" });
+    } catch {
+      art = figlet.textSync(name, { font: "Small", horizontalLayout: "default" });
+    }
+    const artLines = art.split("\n");
+    const lines = artLines.map((line, i) => {
+      const iconStr = getIconForLine(icon, options?.iconSize, i, artLines.length);
+      if (iconStr !== void 0) {
+        return `  ${iconStr}${line}`;
+      }
+      return icon ? `      ${line}` : `  ${line}`;
+    }).join("\n");
+    const colored = GRIMOIRE_GRADIENT(lines);
+    return options?.subtitle ? `${colored}
+  ${theme.muted(options.subtitle)}` : colored;
   } catch {
-    return `  ${prefix}${theme.bold(name)}`;
+    const line = `  ${prefix}${theme.bold(name)}`;
+    return options?.subtitle ? `${line}
+  ${theme.muted(options.subtitle)}` : line;
+  }
+}
+function getIconForLine(icon, iconSize, lineIndex, totalLines) {
+  if (!icon) return void 0;
+  const mid = Math.floor(totalLines / 2);
+  const span = resolveIconSpan(iconSize, totalLines);
+  const halfSpan = Math.floor(span / 2);
+  const start = Math.max(0, mid - halfSpan);
+  const end = Math.min(totalLines - 1, start + span - 1);
+  if (lineIndex >= start && lineIndex <= end) {
+    return lineIndex === mid ? `${icon}  ` : `    `;
+  }
+  return void 0;
+}
+function resolveIconSpan(iconSize, totalLines) {
+  if (typeof iconSize === "number") {
+    const clamped = Math.max(1, Math.floor(isFinite(iconSize) ? iconSize : 1));
+    return Math.min(clamped, totalLines);
+  }
+  switch (iconSize ?? "small") {
+    case "small":
+      return 1;
+    case "medium":
+      return 3;
+    case "large":
+      return totalLines;
   }
 }
 
@@ -1387,7 +1596,14 @@ function emitEvent(renderer, event, theme) {
     renderer.onEvent(event, theme);
   }
 }
-function runPreFlightChecks(checks, theme, renderer) {
+function runPreFlightChecks(checks, theme, renderer, checksStyle) {
+  if (checksStyle === "tasklist") {
+    runPreFlightChecksTasklist(checks, theme, renderer);
+  } else {
+    runPreFlightChecksSpinner(checks, theme, renderer);
+  }
+}
+function runPreFlightChecksSpinner(checks, theme, renderer) {
   if (renderer) emitEvent(renderer, { type: "checks:start", checks }, theme);
   for (const check of checks) {
     if (renderer) emitEvent(renderer, { type: "spinner:start", message: check.name }, theme);
@@ -1405,20 +1621,69 @@ function runPreFlightChecks(checks, theme, renderer) {
   }
   console.log();
 }
+function runPreFlightChecksTasklist(checks, theme, renderer) {
+  if (!process.stdout.isTTY) {
+    runPreFlightChecksSpinner(checks, theme, renderer);
+    return;
+  }
+  if (renderer) emitEvent(renderer, { type: "checks:start", checks, mode: "tasklist" }, theme);
+  const statuses = checks.map(() => "pending");
+  const icons = theme.icons;
+  function renderTasklist() {
+    process.stdout.write(`\x1B[${checks.length}A\x1B[0G`);
+    for (let i = 0; i < checks.length; i++) {
+      const check = checks[i];
+      const s = statuses[i];
+      let icon;
+      if (s === "pass") icon = theme.success(icons.stepDone);
+      else if (s === "fail") icon = theme.error("\u2717");
+      else if (s === "running") icon = theme.info("\u280B");
+      else icon = theme.muted(icons.stepPending);
+      process.stdout.write(`  ${icon}  ${check.name}\x1B[K
+`);
+    }
+  }
+  for (let i = 0; i < checks.length; i++) {
+    process.stdout.write(`  ${theme.muted(icons.stepPending)}  ${checks[i].name}
+`);
+  }
+  let failedCheck;
+  for (let i = 0; i < checks.length; i++) {
+    const check = checks[i];
+    statuses[i] = "running";
+    renderTasklist();
+    try {
+      execSync(check.run, { stdio: "pipe" });
+      statuses[i] = "pass";
+      renderTasklist();
+      if (renderer) emitEvent(renderer, { type: "check:pass", name: check.name }, theme);
+    } catch {
+      statuses[i] = "fail";
+      renderTasklist();
+      failedCheck = check;
+      if (renderer) emitEvent(renderer, { type: "check:fail", name: check.name, message: check.message }, theme);
+      break;
+    }
+  }
+  renderTasklist();
+  console.log();
+  if (failedCheck) {
+    throw new Error(`Pre-flight check failed: ${failedCheck.name} \u2014 ${failedCheck.message}`);
+  }
+}
+var MOCK_MISS = /* @__PURE__ */ Symbol("mock-miss");
 function getMockValue(step, mockAnswers) {
   if (step.id in mockAnswers) {
     return mockAnswers[step.id];
   }
-  if (step.type === "message" || step.type === "note") {
+  if (step.type === "message" || step.type === "note" || step.type === "browser") {
     return true;
   }
   const defaultValue = getStepDefault(step);
   if (defaultValue !== void 0) {
     return defaultValue;
   }
-  throw new Error(
-    `Mock mode: no answer provided for step "${step.id}" and no default available`
-  );
+  return MOCK_MISS;
 }
 function getStepDefault(step) {
   switch (step.type) {
@@ -1438,6 +1703,7 @@ function getStepDefault(step) {
     case "password":
     case "message":
     case "note":
+    case "browser":
       return void 0;
   }
 }
@@ -1473,9 +1739,34 @@ async function runWizard(config, options) {
       registerPlugin(plugin);
     }
   }
+  let cancelFired = false;
+  const performCancel = async () => {
+    if (cancelFired) return;
+    cancelFired = true;
+    state = wizardReducer(state, { type: "CANCEL" }, config);
+    const passwordStepIds = config.steps.filter((s) => s.type === "password").map((s) => s.id);
+    saveProgress(config.meta.name, {
+      currentStepId: state.currentStepId,
+      answers: state.answers,
+      history: state.history
+    }, void 0, passwordStepIds);
+    try {
+      await options?.onCancel?.(state);
+    } catch {
+    }
+    emitEvent(renderer, { type: "session:end", answers: state.answers, cancelled: true }, theme);
+    if (!quiet) console.log(theme.warning("\n  Wizard cancelled.\n"));
+  };
+  const signalHandler = !isMock ? () => {
+    performCancel().finally(() => process.exit(130));
+  } : void 0;
+  if (signalHandler) {
+    process.once("SIGINT", signalHandler);
+    process.once("SIGTERM", signalHandler);
+  }
   try {
     if (!isMock && config.checks && config.checks.length > 0) {
-      runPreFlightChecks(config.checks, theme, renderer);
+      runPreFlightChecks(config.checks, theme, renderer, config.meta.checksStyle);
     }
     if (!quiet) {
       printWizardHeader(config, theme, options?.plain);
@@ -1485,7 +1776,62 @@ async function runWizard(config, options) {
     let needsReview = true;
     while (needsReview) {
       let previousGroup;
+      let stepsCompleted = 0;
       while (state.status === "running") {
+        if (!isMock && config.meta.clearBetweenSteps && stepsCompleted > 0) {
+          renderer.clear();
+          if (!quiet) {
+            printWizardHeader(config, theme, options?.plain);
+          }
+          previousGroup = void 0;
+        }
+        let nextStepOverride;
+        const createHookContext = (stateOverride) => ({
+          answers: { ...(stateOverride ?? state).answers },
+          state: stateOverride ?? state,
+          showNote: (title, body) => {
+            emitEvent(renderer, { type: "note", title, body }, theme);
+            if (!("onEvent" in renderer) && process.stdout.isTTY) {
+              console.log(`
+  ${theme.bold(title)}`);
+              if (body) console.log(`  ${theme.muted(body)}`);
+              console.log();
+            }
+          },
+          setNextStep: (stepId) => {
+            nextStepOverride = stepId;
+          },
+          openBrowser: async (url) => {
+            if (isMock) return;
+            try {
+              new URL(url);
+            } catch {
+              return;
+            }
+            if (process.platform === "darwin") {
+              execFileSync("open", [url], { stdio: "ignore" });
+            } else if (process.platform === "win32") {
+              execFileSync("powershell", ["-NoProfile", "-Command", `Start-Process '${url.replace(/'/g, "''")}'`], { stdio: "ignore" });
+            } else {
+              execFileSync("xdg-open", [url], { stdio: "ignore" });
+            }
+          },
+          prompt: async (promptConfig) => {
+            if (isMock) {
+              if (promptConfig.default !== void 0) return promptConfig.default;
+              throw new Error("Mock mode: context.prompt() requires a default value");
+            }
+            const contextState = stateOverride ?? state;
+            const tempStep = {
+              id: "__hook_prompt__",
+              message: promptConfig.message,
+              type: promptConfig.type,
+              ...promptConfig.type === "select" ? { options: promptConfig.options } : {},
+              default: promptConfig.default
+            };
+            return renderStep(renderer, tempStep, contextState, theme);
+          }
+        });
         const visibleSteps = getVisibleSteps(config, state.answers);
         const currentStep = config.steps.find((s) => s.id === state.currentStepId);
         if (!currentStep) {
@@ -1508,9 +1854,13 @@ async function runWizard(config, options) {
         emitEvent(renderer, { type: "step:start", stepId: currentStep.id, stepIndex, totalVisible: visibleSteps.length, step: currentStep }, theme);
         if (currentStep.type === "note") {
           emitEvent(renderer, { type: "note", title: resolvedMessage, body: resolvedDescription ?? "" }, theme);
+          if (!isMock && "style" in currentStep && currentStep.style && "renderNote" in renderer && !("onEvent" in renderer)) {
+            const resolvedStep2 = { ...currentStep, message: resolvedMessage, description: resolvedDescription };
+            renderer.renderNote(resolvedStep2, theme);
+          }
         }
         if (options?.onBeforeStep) {
-          await options.onBeforeStep(currentStep.id, currentStep, state);
+          await options.onBeforeStep(currentStep.id, currentStep, createHookContext());
         }
         const pluginStep = getPluginStep(currentStep.type);
         const resolvedStep = pluginStep ? currentStep : resolveStepDefaults(currentStep, cachedAnswers);
@@ -1527,7 +1877,19 @@ async function runWizard(config, options) {
           }
         }
         try {
-          const value = isMock ? getMockValue(finalStep, mockAnswers) : pluginStep ? await pluginStep.render(toStepRecord(finalStep), state, theme) : await renderStep(renderer, finalStep, state, theme);
+          let value;
+          if (isMock) {
+            const mockResult = getMockValue(finalStep, mockAnswers);
+            if (mockResult === MOCK_MISS) {
+              throw new Error(
+                `Mock mode: no answer provided for step "${finalStep.id}" and no default available`
+              );
+            } else {
+              value = mockResult;
+            }
+          } else {
+            value = pluginStep ? await pluginStep.render(toStepRecord(finalStep), state, theme) : await renderStep(renderer, finalStep, state, theme);
+          }
           if (pluginStep?.validate) {
             const pluginError = pluginStep.validate(value, toStepRecord(templatedStep));
             if (pluginError) {
@@ -1568,28 +1930,31 @@ async function runWizard(config, options) {
             }
           }
           if (options?.onAfterStep) {
-            await options.onAfterStep(currentStep.id, value, nextState);
+            await options.onAfterStep(currentStep.id, value, createHookContext(nextState));
+          }
+          if (nextStepOverride) {
+            if (nextStepOverride === "__done__") {
+              state = { ...nextState, status: "done" };
+            } else {
+              const targetExists = config.steps.some((s) => s.id === nextStepOverride);
+              if (!targetExists) {
+                throw new Error(`setNextStep: step "${nextStepOverride}" does not exist`);
+              }
+              state = { ...nextState, status: "running", currentStepId: nextStepOverride };
+            }
+            nextStepOverride = void 0;
+          } else {
+            state = nextState;
           }
-          state = nextState;
           emitEvent(renderer, { type: "step:complete", stepId: currentStep.id, value, step: currentStep }, theme);
           if (mruEnabled && isSelectLikeStep(currentStep.type)) {
             recordSelection(config.meta.name, currentStep.id, value);
           }
           options?.onStepComplete?.(currentStep.id, value, state);
+          stepsCompleted++;
         } catch (error) {
           if (!isMock && isUserCancel(error)) {
-            state = wizardReducer(state, { type: "CANCEL" }, config);
-            options?.onCancel?.(state);
-            const passwordStepIds = config.steps.filter((s) => s.type === "password").map((s) => s.id);
-            saveProgress(config.meta.name, {
-              currentStepId: state.currentStepId,
-              answers: state.answers,
-              history: state.history
-            }, void 0, passwordStepIds);
-            emitEvent(renderer, { type: "session:end", answers: state.answers, cancelled: true }, theme);
-            if (!quiet) {
-              console.log(theme.warning("\n  Wizard cancelled.\n"));
-            }
+            await performCancel();
             return state.answers;
           }
           throw error;
@@ -1598,10 +1963,14 @@ async function runWizard(config, options) {
       if (config.meta.review && !isMock && state.status === "done") {
         const reviewLines = [];
         for (const step of config.steps) {
+          if (step.review?.hide) continue;
+          if (step.type === "note" || step.type === "message") continue;
           const answer = state.answers[step.id];
           if (answer === void 0) continue;
-          const display = step.type === "password" ? "****" : Array.isArray(answer) ? answer.map(String).join(", ") : String(answer);
-          reviewLines.push(`${step.id}: ${display}`);
+          const label = step.review?.label ?? step.id;
+          const raw = step.type === "password" ? "****" : Array.isArray(answer) ? answer.map(String).join(", ") : String(answer);
+          const display = formatReviewValue(raw, step.review?.format);
+          reviewLines.push(`${label}: ${display}`);
         }
         emitEvent(renderer, { type: "note", title: "Review your answers", body: reviewLines.join("\n") }, theme);
         console.log(`
@@ -1621,12 +1990,16 @@ async function runWizard(config, options) {
         } else {
           const { select: selectPrompt } = await import("@inquirer/prompts");
           const stepsWithAnswers = config.steps.filter(
-            (s) => state.answers[s.id] !== void 0 && s.type !== "note" && s.type !== "message"
+            (s) => state.answers[s.id] !== void 0 && s.type !== "note" && s.type !== "message" && !s.review?.hide
           );
+          if (stepsWithAnswers.length === 0) {
+            needsReview = false;
+            break;
+          }
           const stepToRevisit = await selectPrompt({
             message: "Which step would you like to change?",
             choices: stepsWithAnswers.map((s) => ({
-              name: `${s.id}: ${s.type === "password" ? "****" : String(state.answers[s.id] ?? "")}`,
+              name: `${s.review?.label ?? s.id}: ${s.type === "password" ? "****" : String(state.answers[s.id] ?? "")}`,
               value: s.id
             }))
           });
@@ -1669,6 +2042,10 @@ async function runWizard(config, options) {
     }
     return state.answers;
   } finally {
+    if (signalHandler) {
+      process.removeListener("SIGINT", signalHandler);
+      process.removeListener("SIGTERM", signalHandler);
+    }
     if (userPlugins) {
       clearPlugins();
     }
@@ -1708,6 +2085,18 @@ function renderStep(renderer, step, state, theme) {
       return Promise.resolve(true);
     case "note":
       return Promise.resolve(true);
+    case "browser": {
+      const resolvedUrl = resolveTemplate(step.url, state.answers);
+      console.log(`
+  ${theme.info("\u2192")} ${step.message}`);
+      console.log(`  ${theme.muted(resolvedUrl)}`);
+      openUrl(resolvedUrl);
+      if (step.fallback) {
+        console.log(`  ${theme.muted(step.fallback)}`);
+      }
+      console.log();
+      return Promise.resolve(true);
+    }
   }
 }
 function resolveStepDefaults(step, cachedAnswers) {
@@ -1759,6 +2148,7 @@ function resolveStepDefaults(step, cachedAnswers) {
     case "password":
     case "message":
     case "note":
+    case "browser":
       return step;
   }
 }
@@ -1768,7 +2158,7 @@ function getCachedDefault(stepId, cachedAnswers) {
 }
 function applyTemplateDefaults(step, templateAnswers) {
   if (!(step.id in templateAnswers)) return step;
-  if (step.type === "password" || step.type === "message" || step.type === "note") return step;
+  if (step.type === "password" || step.type === "message" || step.type === "note" || step.type === "browser") return step;
   const value = templateAnswers[step.id];
   switch (step.type) {
     case "text":
@@ -1858,6 +2248,7 @@ function resolveStepTemplates(step, answers) {
     case "toggle":
     case "message":
     case "note":
+    case "browser":
       return {
         ...step,
         description: step.description ? resolveTemplate(step.description, answers) : void 0
@@ -1915,18 +2306,50 @@ async function executeActions(actions, answers, theme, renderer) {
 }
 function printWizardHeader(config, theme, plain) {
   console.log();
-  console.log(renderBanner(config.meta.name, theme, { plain, icon: config.meta.icon }));
+  console.log(renderBanner(config.meta.name, theme, {
+    plain,
+    icon: config.meta.icon,
+    iconSize: config.meta.iconSize,
+    font: config.meta.font,
+    banner: config.meta.banner,
+    subtitle: config.meta.subtitle
+  }));
   if (config.meta.description) {
     console.log(`  ${theme.muted(config.meta.description)}`);
   }
   console.log();
 }
+function openUrl(url) {
+  try {
+    if (process.platform === "darwin") {
+      execFileSync("open", [url], { stdio: "ignore" });
+    } else if (process.platform === "win32") {
+      const safeUrl = url.replace(/'/g, "''");
+      execFileSync("powershell", ["-NoProfile", "-Command", `Start-Process '${safeUrl}'`], { stdio: "ignore" });
+    } else {
+      execFileSync("xdg-open", [url], { stdio: "ignore" });
+    }
+  } catch {
+  }
+}
 function isUserCancel(error) {
   if (error instanceof Error) {
     return error.message.includes("User force closed") || error.name === "ExitPromptError";
   }
   return false;
 }
+function formatReviewValue(value, format) {
+  switch (format) {
+    case "uppercase":
+      return value.toUpperCase();
+    case "lowercase":
+      return value.toLowerCase();
+    case "capitalize":
+      return value.charAt(0).toUpperCase() + value.slice(1);
+    default:
+      return value;
+  }
+}
 
 // src/scaffolder.ts
 import { input as input2, select as select2, confirm as confirm2, number as number2 } from "@inquirer/prompts";
@@ -2396,8 +2819,9 @@ var InkRenderer = class {
     return result ?? defaultValue ?? 0;
   }
   async renderSearch(step, _state, theme) {
+    const message = step.placeholder ? `${step.message} ${theme.muted(`(${step.placeholder})`)}` : step.message;
     return search2({
-      message: step.message,
+      message,
       source: (term) => {
         const query = (term ?? "").toLowerCase();
         return step.options.filter((opt) => "value" in opt).filter((opt) => !opt.disabled && opt.label.toLowerCase().includes(query)).map((opt) => ({
@@ -2501,6 +2925,8 @@ var S_BAR_H = u("\u2500", "-");
 var ClackRenderer = class extends InquirerRenderer {
   spinnerInterval;
   spinnerFrameIndex = 0;
+  spinnerStartTime = 0;
+  checksMode = void 0;
   renderStepHeader() {
   }
   renderGroupHeader() {
@@ -2557,18 +2983,25 @@ var ClackRenderer = class extends InquirerRenderer {
         this.stopSpinner(event.message, theme);
         break;
       case "checks:start":
-        process.stdout.write(`${chalk2.gray(S_BAR)}
+        this.checksMode = event.mode === "tasklist" ? "tasklist" : "spinner";
+        if (this.checksMode !== "tasklist") {
+          process.stdout.write(`${chalk2.gray(S_BAR)}
 `);
-        process.stdout.write(`${chalk2.gray(S_BAR)}  ${theme.bold("Running checks...")}
+          process.stdout.write(`${chalk2.gray(S_BAR)}  ${theme.bold("Running checks...")}
 `);
+        }
         break;
       case "check:pass":
-        process.stdout.write(`${chalk2.gray(S_BAR)}  ${theme.success(S_STEP_SUBMIT)}  ${event.name}
+        if (this.checksMode !== "tasklist") {
+          process.stdout.write(`${chalk2.gray(S_BAR)}  ${theme.success(S_STEP_SUBMIT)}  ${event.name}
 `);
+        }
         break;
       case "check:fail":
-        process.stdout.write(`${chalk2.gray(S_BAR)}  ${theme.error(S_STEP_ERROR)}  ${event.name}: ${event.message}
+        if (this.checksMode !== "tasklist") {
+          process.stdout.write(`${chalk2.gray(S_BAR)}  ${theme.error(S_STEP_ERROR)}  ${event.name}: ${event.message}
 `);
+        }
         break;
       case "actions:start":
         process.stdout.write(`${chalk2.gray(S_BAR)}
@@ -2635,11 +3068,17 @@ var ClackRenderer = class extends InquirerRenderer {
 `);
   }
   startSpinner(message, theme) {
+    if (this.spinnerInterval) {
+      clearInterval(this.spinnerInterval);
+      this.spinnerInterval = void 0;
+    }
     this.spinnerFrameIndex = 0;
+    this.spinnerStartTime = Date.now();
     const { frames, interval } = theme.spinner;
     this.spinnerInterval = setInterval(() => {
       const frame = frames[this.spinnerFrameIndex % frames.length];
-      process.stdout.write(`\r${chalk2.gray(S_BAR)}  ${chalk2.cyan(frame ?? "")}  ${message}`);
+      const elapsed = theme.spinnerElapsed ? `  ${chalk2.gray(`(${((Date.now() - this.spinnerStartTime) / 1e3).toFixed(1)}s)`)}` : "";
+      process.stdout.write(`\r${chalk2.gray(S_BAR)}  ${chalk2.cyan(frame ?? "")}  ${message}${elapsed}`);
       this.spinnerFrameIndex++;
     }, interval);
   }
@@ -2649,7 +3088,7 @@ var ClackRenderer = class extends InquirerRenderer {
       this.spinnerInterval = void 0;
     }
     const finalMessage = message ?? "Done";
-    process.stdout.write(`\r${chalk2.gray(S_BAR)}  ${theme.success(S_STEP_SUBMIT)}  ${finalMessage}
+    process.stdout.write(`\r${chalk2.gray(S_BAR)}  ${theme.success(S_STEP_SUBMIT)}  ${finalMessage}\x1B[K
 `);
   }
 };