grimoire-wizard 0.3.0

package/dist/cli.js

@@ -0,0 +1,2485 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import chalk2 from "chalk";
+import { program } from "commander";
+
+// src/parser.ts
+import { cosmiconfig } from "cosmiconfig";
+import { readFileSync } from "fs";
+import { dirname, resolve, isAbsolute } from "path";
+import { parse as parseYAML } from "yaml";
+
+// src/schema.ts
+import { z } from "zod";
+var conditionSchema = z.lazy(() => {
+  const fieldEquals = z.object({ field: z.string(), equals: z.unknown() }).strict();
+  const fieldNotEquals = z.object({ field: z.string(), notEquals: z.unknown() }).strict();
+  const fieldIncludes = z.object({ field: z.string(), includes: z.unknown() }).strict();
+  const fieldNotIncludes = z.object({ field: z.string(), notIncludes: z.unknown() }).strict();
+  const fieldGreaterThan = z.object({ field: z.string(), greaterThan: z.number() }).strict();
+  const fieldLessThan = z.object({ field: z.string(), lessThan: z.number() }).strict();
+  const fieldIsEmpty = z.object({ field: z.string(), isEmpty: z.literal(true) }).strict();
+  const fieldIsNotEmpty = z.object({ field: z.string(), isNotEmpty: z.literal(true) }).strict();
+  const allCondition = z.object({ all: z.array(conditionSchema) }).strict();
+  const anyCondition = z.object({ any: z.array(conditionSchema) }).strict();
+  const notCondition = z.object({ not: conditionSchema }).strict();
+  return z.union([
+    fieldEquals,
+    fieldNotEquals,
+    fieldIncludes,
+    fieldNotIncludes,
+    fieldGreaterThan,
+    fieldLessThan,
+    fieldIsEmpty,
+    fieldIsNotEmpty,
+    allCondition,
+    anyCondition,
+    notCondition
+  ]);
+});
+var validationRuleSchema = z.discriminatedUnion("rule", [
+  z.object({ rule: z.literal("required"), message: z.string().optional() }),
+  z.object({ rule: z.literal("minLength"), value: z.number(), message: z.string().optional() }),
+  z.object({ rule: z.literal("maxLength"), value: z.number(), message: z.string().optional() }),
+  z.object({ rule: z.literal("pattern"), value: z.string(), message: z.string().optional() }),
+  z.object({ rule: z.literal("min"), value: z.number(), message: z.string().optional() }),
+  z.object({ rule: z.literal("max"), value: z.number(), message: z.string().optional() })
+]);
+var selectOptionSchema = z.object({
+  value: z.string(),
+  label: z.string(),
+  hint: z.string().optional(),
+  disabled: z.union([z.boolean(), z.string()]).optional()
+});
+var separatorOptionSchema = z.object({
+  separator: z.string()
+});
+var selectChoiceSchema = z.union([selectOptionSchema, separatorOptionSchema]);
+var baseStepFields = {
+  id: z.string(),
+  message: z.string(),
+  description: z.string().optional(),
+  next: z.string().optional(),
+  when: conditionSchema.optional(),
+  keepValuesOnPrevious: z.boolean().optional(),
+  required: z.boolean().optional(),
+  group: z.string().optional()
+};
+var textStepSchema = z.object({
+  ...baseStepFields,
+  type: z.literal("text"),
+  placeholder: z.string().optional(),
+  default: z.string().optional(),
+  validate: z.array(validationRuleSchema).optional()
+});
+var selectStepSchema = z.object({
+  ...baseStepFields,
+  type: z.literal("select"),
+  options: z.array(selectChoiceSchema).min(1).optional(),
+  optionsFrom: z.string().optional(),
+  default: z.string().optional(),
+  routes: z.record(z.string(), z.string()).optional(),
+  pageSize: z.number().int().positive().optional(),
+  loop: z.boolean().optional()
+});
+var multiSelectStepSchema = z.object({
+  ...baseStepFields,
+  type: z.literal("multiselect"),
+  options: z.array(selectChoiceSchema).min(1).optional(),
+  optionsFrom: z.string().optional(),
+  default: z.array(z.string()).optional(),
+  min: z.number().int().nonnegative().optional(),
+  max: z.number().int().positive().optional(),
+  pageSize: z.number().int().positive().optional(),
+  loop: z.boolean().optional()
+});
+var confirmStepSchema = z.object({
+  ...baseStepFields,
+  type: z.literal("confirm"),
+  default: z.boolean().optional()
+});
+var passwordStepSchema = z.object({
+  ...baseStepFields,
+  type: z.literal("password"),
+  validate: z.array(validationRuleSchema).optional()
+});
+var numberStepSchema = z.object({
+  ...baseStepFields,
+  type: z.literal("number"),
+  default: z.number().optional(),
+  min: z.number().optional(),
+  max: z.number().optional(),
+  step: z.number().positive().optional()
+});
+var searchStepSchema = z.object({
+  ...baseStepFields,
+  type: z.literal("search"),
+  options: z.array(selectChoiceSchema).min(1).optional(),
+  optionsFrom: z.string().optional(),
+  default: z.string().optional(),
+  placeholder: z.string().optional(),
+  pageSize: z.number().int().positive().optional(),
+  loop: z.boolean().optional()
+});
+var editorStepSchema = z.object({
+  ...baseStepFields,
+  type: z.literal("editor"),
+  default: z.string().optional(),
+  validate: z.array(validationRuleSchema).optional()
+});
+var pathStepSchema = z.object({
+  ...baseStepFields,
+  type: z.literal("path"),
+  default: z.string().optional(),
+  placeholder: z.string().optional(),
+  validate: z.array(validationRuleSchema).optional()
+});
+var toggleStepSchema = z.object({
+  ...baseStepFields,
+  type: z.literal("toggle"),
+  default: z.boolean().optional(),
+  active: z.string().optional(),
+  inactive: z.string().optional()
+});
+var messageStepSchema = z.object({
+  ...baseStepFields,
+  type: z.literal("message")
+});
+var stepConfigSchema = z.discriminatedUnion("type", [
+  textStepSchema,
+  selectStepSchema,
+  multiSelectStepSchema,
+  confirmStepSchema,
+  passwordStepSchema,
+  numberStepSchema,
+  searchStepSchema,
+  editorStepSchema,
+  pathStepSchema,
+  toggleStepSchema,
+  messageStepSchema
+]);
+var hexColorSchema = z.string().regex(
+  /^#[0-9a-fA-F]{6}$/,
+  "Must be a 6-digit hex color (e.g., #FF0000)"
+);
+var themeConfigSchema = z.object({
+  tokens: z.object({
+    primary: hexColorSchema.optional(),
+    success: hexColorSchema.optional(),
+    error: hexColorSchema.optional(),
+    warning: hexColorSchema.optional(),
+    info: hexColorSchema.optional(),
+    muted: hexColorSchema.optional(),
+    accent: hexColorSchema.optional()
+  }).optional(),
+  icons: z.object({
+    step: z.string().optional(),
+    stepDone: z.string().optional(),
+    stepPending: z.string().optional(),
+    pointer: z.string().optional()
+  }).optional()
+});
+var preFlightCheckSchema = z.object({
+  name: z.string(),
+  run: z.string(),
+  message: z.string()
+});
+var actionConfigSchema = z.object({
+  name: z.string().optional(),
+  run: z.string(),
+  when: conditionSchema.optional()
+});
+var wizardConfigSchema = z.object({
+  meta: z.object({
+    name: z.string(),
+    version: z.string().optional(),
+    description: z.string().optional()
+  }),
+  theme: themeConfigSchema.optional(),
+  steps: z.array(stepConfigSchema).min(1),
+  output: z.object({
+    format: z.enum(["json", "env", "yaml"]),
+    path: z.string().optional()
+  }).optional(),
+  extends: z.string().optional(),
+  checks: z.array(preFlightCheckSchema).optional(),
+  actions: z.array(actionConfigSchema).optional()
+}).superRefine((config, ctx) => {
+  const stepIds = /* @__PURE__ */ new Set();
+  for (const step of config.steps) {
+    if (stepIds.has(step.id)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `Duplicate step ID: "${step.id}"`,
+        path: ["steps"]
+      });
+    }
+    stepIds.add(step.id);
+  }
+  config.steps.forEach((step, i) => {
+    if (step.next && step.next !== "__done__" && !stepIds.has(step.next)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `Step "${step.id}" references unknown next step: "${step.next}"`,
+        path: ["steps", i, "next"]
+      });
+    }
+    if (step.type === "select" && step.routes) {
+      for (const [key, target] of Object.entries(step.routes)) {
+        if (target !== "__done__" && !stepIds.has(target)) {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `Step "${step.id}" route "${key}" references unknown step: "${target}"`,
+            path: ["steps", i, "routes", key]
+          });
+        }
+      }
+    }
+    if (step.when) {
+      collectConditionFieldIssues(step.when, stepIds, ctx, ["steps", i, "when"]);
+    }
+    if (step.type === "select" && step.routes && step.options) {
+      const optionValues = /* @__PURE__ */ new Set();
+      for (const o of step.options) {
+        if ("value" in o) {
+          optionValues.add(o.value);
+        }
+      }
+      for (const routeKey of Object.keys(step.routes)) {
+        if (!optionValues.has(routeKey)) {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `Step "${step.id}" route key "${routeKey}" does not match any option value`,
+            path: ["steps", i, "routes", routeKey]
+          });
+        }
+      }
+    }
+    if (step.type === "select" || step.type === "multiselect" || step.type === "search") {
+      const hasOptions = step.options !== void 0;
+      const hasOptionsFrom = step.optionsFrom !== void 0;
+      if (hasOptions && hasOptionsFrom) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: `Step "${step.id}" has both "options" and "optionsFrom" \u2014 only one is allowed`,
+          path: ["steps", i]
+        });
+      }
+      if (!hasOptions && !hasOptionsFrom) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: `Step "${step.id}" must have either "options" or "optionsFrom"`,
+          path: ["steps", i]
+        });
+      }
+    }
+    if ((step.type === "number" || step.type === "multiselect") && step.min !== void 0 && step.max !== void 0 && step.min > step.max) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `Step "${step.id}" has min (${String(step.min)}) greater than max (${String(step.max)})`,
+        path: ["steps", i]
+      });
+    }
+  });
+  if (config.actions) {
+    config.actions.forEach((action, i) => {
+      if (action.when) {
+        collectConditionFieldIssues(action.when, stepIds, ctx, ["actions", i, "when"]);
+      }
+    });
+  }
+});
+function collectConditionFieldIssues(condition, validIds, ctx, path) {
+  if ("field" in condition) {
+    const fieldRoot = condition.field.split(".")[0];
+    if (fieldRoot && !validIds.has(fieldRoot)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `Condition references unknown step ID: "${fieldRoot}"`,
+        path
+      });
+    }
+    return;
+  }
+  if ("all" in condition) {
+    condition.all.forEach((child, i) => {
+      collectConditionFieldIssues(child, validIds, ctx, [...path, "all", i]);
+    });
+    return;
+  }
+  if ("any" in condition) {
+    condition.any.forEach((child, i) => {
+      collectConditionFieldIssues(child, validIds, ctx, [...path, "any", i]);
+    });
+    return;
+  }
+  if ("not" in condition) {
+    collectConditionFieldIssues(condition.not, validIds, ctx, [...path, "not"]);
+  }
+}
+function parseWizardConfig(raw) {
+  const result = wizardConfigSchema.parse(raw);
+  return result;
+}
+
+// src/parser.ts
+var DONE_SENTINEL = "__done__";
+function buildStepGraph(steps) {
+  const graph = /* @__PURE__ */ new Map();
+  for (let i = 0; i < steps.length; i++) {
+    const step = steps[i];
+    const edges = [];
+    if (step.next && step.next !== DONE_SENTINEL) {
+      edges.push(step.next);
+    }
+    if (step.type === "select" && step.routes) {
+      for (const target of Object.values(step.routes)) {
+        if (target !== DONE_SENTINEL) {
+          edges.push(target);
+        }
+      }
+    }
+    if (!step.next && !(step.type === "select" && step.routes)) {
+      const nextStep = steps[i + 1];
+      if (nextStep) {
+        edges.push(nextStep.id);
+      }
+    }
+    graph.set(step.id, edges);
+  }
+  return graph;
+}
+function detectCycles(config) {
+  const graph = buildStepGraph(config.steps);
+  const UNVISITED = 0;
+  const IN_STACK = 1;
+  const DONE = 2;
+  const nodeState = /* @__PURE__ */ new Map();
+  for (const id of graph.keys()) {
+    nodeState.set(id, UNVISITED);
+  }
+  function dfs(nodeId, path) {
+    nodeState.set(nodeId, IN_STACK);
+    const currentPath = [...path, nodeId];
+    for (const neighbor of graph.get(nodeId) ?? []) {
+      const state = nodeState.get(neighbor);
+      if (state === IN_STACK) {
+        const cycleStart = currentPath.indexOf(neighbor);
+        const cycle = [...currentPath.slice(cycleStart), neighbor];
+        throw new Error(`Cycle detected in wizard steps: ${cycle.join(" \u2192 ")}`);
+      }
+      if (state === UNVISITED) {
+        dfs(neighbor, currentPath);
+      }
+    }
+    nodeState.set(nodeId, DONE);
+  }
+  for (const id of graph.keys()) {
+    if (nodeState.get(id) === UNVISITED) {
+      dfs(id, []);
+    }
+  }
+}
+function deepMergeTheme(parent, child) {
+  if (!parent && !child) return void 0;
+  if (!parent) return child;
+  if (!child) return parent;
+  return {
+    tokens: { ...parent.tokens, ...child.tokens },
+    icons: { ...parent.icons, ...child.icons }
+  };
+}
+function mergeConfigs(parent, child) {
+  return {
+    meta: { ...parent.meta, ...child.meta },
+    theme: deepMergeTheme(parent.theme, child.theme),
+    steps: child.steps,
+    output: child.output ?? parent.output,
+    checks: [
+      ...parent.checks ?? [],
+      ...child.checks ?? []
+    ],
+    actions: child.actions ?? parent.actions
+  };
+}
+var OPTION_STEP_TYPES = /* @__PURE__ */ new Set(["select", "multiselect", "search"]);
+function resolveOptionsFromSteps(raw, configDir) {
+  const steps = raw["steps"];
+  if (!Array.isArray(steps)) return;
+  for (const step of steps) {
+    if (typeof step !== "object" || step === null) continue;
+    const stepObj = step;
+    const optionsFrom = stepObj["optionsFrom"];
+    if (typeof optionsFrom !== "string") continue;
+    const stepId = String(stepObj["id"] ?? "unknown");
+    const stepType = String(stepObj["type"] ?? "unknown");
+    if (!OPTION_STEP_TYPES.has(stepType)) {
+      throw new Error(
+        `Step "${stepId}" has "optionsFrom" but type "${stepType}" does not support dynamic options`
+      );
+    }
+    const fullPath = isAbsolute(optionsFrom) ? optionsFrom : resolve(configDir, optionsFrom);
+    let content;
+    try {
+      content = readFileSync(fullPath, "utf-8");
+    } catch {
+      throw new Error(
+        `Step "${stepId}": failed to read optionsFrom file "${fullPath}"`
+      );
+    }
+    let parsed;
+    try {
+      if (fullPath.endsWith(".yaml") || fullPath.endsWith(".yml")) {
+        parsed = parseYAML(content);
+      } else {
+        parsed = JSON.parse(content);
+      }
+    } catch {
+      throw new Error(
+        `Step "${stepId}": optionsFrom file "${fullPath}" contains invalid JSON/YAML`
+      );
+    }
+    if (!Array.isArray(parsed)) {
+      throw new Error(
+        `Step "${stepId}": optionsFrom file "${fullPath}" must contain an array`
+      );
+    }
+    stepObj["options"] = parsed;
+    delete stepObj["optionsFrom"];
+  }
+}
+async function loadWithInheritance(filePath, seen) {
+  const resolvedPath = resolve(filePath);
+  if (seen.has(resolvedPath)) {
+    throw new Error(`Circular extends detected: "${resolvedPath}" was already loaded`);
+  }
+  seen.add(resolvedPath);
+  const explorer = cosmiconfig("grimoire");
+  const result = await explorer.load(resolvedPath);
+  if (!result || result.isEmpty) {
+    throw new Error(`No configuration found at: ${resolvedPath}`);
+  }
+  const raw = result.config;
+  const extendsPath = typeof raw["extends"] === "string" ? raw["extends"] : void 0;
+  resolveOptionsFromSteps(raw, dirname(resolvedPath));
+  const config = parseWizardConfig(raw);
+  if (!extendsPath) {
+    return config;
+  }
+  const parentPath = isAbsolute(extendsPath) ? extendsPath : resolve(dirname(resolvedPath), extendsPath);
+  const parentConfig = await loadWithInheritance(parentPath, seen);
+  return mergeConfigs(parentConfig, config);
+}
+async function loadWizardConfig(filePath) {
+  const config = await loadWithInheritance(filePath, /* @__PURE__ */ new Set());
+  detectCycles(config);
+  return config;
+}
+
+// src/runner.ts
+import { execSync } from "child_process";
+
+// src/conditions.ts
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function getValueByPath(obj, path) {
+  const segments = path.split(".");
+  let current = obj;
+  for (const segment of segments) {
+    if (!isRecord(current)) {
+      return void 0;
+    }
+    current = current[segment];
+  }
+  return current;
+}
+function evaluateCondition(condition, answers) {
+  if ("all" in condition) {
+    return condition.all.every((c) => evaluateCondition(c, answers));
+  }
+  if ("any" in condition) {
+    return condition.any.some((c) => evaluateCondition(c, answers));
+  }
+  if ("not" in condition) {
+    return !evaluateCondition(condition.not, answers);
+  }
+  const value = getValueByPath(answers, condition.field);
+  if ("isEmpty" in condition) {
+    if (value === void 0 || value === null) return true;
+    if (typeof value === "string") return value.length === 0;
+    if (Array.isArray(value)) return value.length === 0;
+    return false;
+  }
+  if ("isNotEmpty" in condition) {
+    if (value === void 0 || value === null) return false;
+    if (typeof value === "string") return value.length > 0;
+    if (Array.isArray(value)) return value.length > 0;
+    return true;
+  }
+  if (value === void 0 || value === null) {
+    return false;
+  }
+  if ("equals" in condition) {
+    return value === condition.equals;
+  }
+  if ("notEquals" in condition) {
+    return value !== condition.notEquals;
+  }
+  if ("includes" in condition) {
+    if (Array.isArray(value)) {
+      return value.includes(condition.includes);
+    }
+    if (typeof value === "string" && typeof condition.includes === "string") {
+      return value.includes(condition.includes);
+    }
+    return false;
+  }
+  if ("notIncludes" in condition) {
+    if (Array.isArray(value)) {
+      return !value.includes(condition.notIncludes);
+    }
+    if (typeof value === "string" && typeof condition.notIncludes === "string") {
+      return !value.includes(condition.notIncludes);
+    }
+    return false;
+  }
+  if ("greaterThan" in condition) {
+    return typeof value === "number" && value > condition.greaterThan;
+  }
+  if ("lessThan" in condition) {
+    return typeof value === "number" && value < condition.lessThan;
+  }
+  return false;
+}
+function isStepVisible(step, answers) {
+  if (!step.when) {
+    return true;
+  }
+  return evaluateCondition(step.when, answers);
+}
+
+// src/engine.ts
+function createWizardState(config) {
+  const firstVisible = config.steps.find((s) => isStepVisible(s, {}));
+  if (!firstVisible) {
+    throw new Error("No visible steps in wizard configuration");
+  }
+  return {
+    currentStepId: firstVisible.id,
+    answers: {},
+    history: [],
+    status: "running",
+    errors: {}
+  };
+}
+function validateStepAnswer(step, value) {
+  if (step.type === "message") {
+    return null;
+  }
+  const isRequired = step.required !== false;
+  if (isRequired) {
+    if (value === void 0 || value === null || value === "") {
+      return "This field is required";
+    }
+    if (Array.isArray(value) && value.length === 0) {
+      return "This field is required";
+    }
+  }
+  if ((step.type === "text" || step.type === "password" || step.type === "editor" || step.type === "path") && step.validate) {
+    const strValue = typeof value === "string" ? value : String(value ?? "");
+    for (const rule of step.validate) {
+      const error = applyValidationRule(rule, strValue);
+      if (error) return error;
+    }
+  }
+  if (step.type === "number" && typeof value === "number") {
+    if (step.min !== void 0 && value < step.min) {
+      return `Must be at least ${String(step.min)}`;
+    }
+    if (step.max !== void 0 && value > step.max) {
+      return `Must be at most ${String(step.max)}`;
+    }
+  }
+  if (step.type === "multiselect" && Array.isArray(value)) {
+    if (step.min !== void 0 && value.length < step.min) {
+      return `Select at least ${String(step.min)} option${step.min === 1 ? "" : "s"}`;
+    }
+    if (step.max !== void 0 && value.length > step.max) {
+      return `Select at most ${String(step.max)} option${step.max === 1 ? "" : "s"}`;
+    }
+  }
+  return null;
+}
+function resolveNextStep(config, currentStep, answer, answers) {
+  let targetId;
+  if (currentStep.type === "select" && currentStep.routes) {
+    const route = currentStep.routes[String(answer)];
+    if (route === "__done__") return "__done__";
+    if (route) targetId = route;
+  }
+  if (!targetId && currentStep.next) {
+    if (currentStep.next === "__done__") return "__done__";
+    targetId = currentStep.next;
+  }
+  if (!targetId) {
+    const currentIndex = config.steps.findIndex((s) => s.id === currentStep.id);
+    const nextInArray = config.steps[currentIndex + 1];
+    if (!nextInArray) return "__done__";
+    targetId = nextInArray.id;
+  }
+  const targetIndex = config.steps.findIndex((s) => s.id === targetId);
+  if (targetIndex < 0) return "__done__";
+  for (let i = targetIndex; i < config.steps.length; i++) {
+    const step = config.steps[i];
+    if (step && isStepVisible(step, answers)) {
+      return step.id;
+    }
+  }
+  return "__done__";
+}
+function getVisibleSteps(config, answers) {
+  return config.steps.filter((s) => isStepVisible(s, answers));
+}
+function wizardReducer(state, transition, config) {
+  switch (transition.type) {
+    case "NEXT": {
+      const currentStep = findStepOrThrow(config, state.currentStepId);
+      const validationError = validateStepAnswer(currentStep, transition.value);
+      if (validationError) {
+        return {
+          ...state,
+          errors: { ...state.errors, [state.currentStepId]: validationError }
+        };
+      }
+      const updatedAnswers = {
+        ...state.answers,
+        [state.currentStepId]: transition.value
+      };
+      const nextStepId = resolveNextStep(
+        config,
+        currentStep,
+        transition.value,
+        updatedAnswers
+      );
+      if (nextStepId === "__done__") {
+        return {
+          ...state,
+          answers: updatedAnswers,
+          history: [...state.history, state.currentStepId],
+          status: "done",
+          errors: {}
+        };
+      }
+      const finalAnswers = cleanOrphanedAnswers(
+        config,
+        updatedAnswers,
+        state.currentStepId,
+        nextStepId
+      );
+      return {
+        ...state,
+        currentStepId: nextStepId,
+        answers: finalAnswers,
+        history: [...state.history, state.currentStepId],
+        status: "running",
+        errors: {}
+      };
+    }
+    case "BACK": {
+      if (state.history.length === 0) {
+        return state;
+      }
+      const previousStepId = state.history[state.history.length - 1];
+      const currentStep = config.steps.find((s) => s.id === state.currentStepId);
+      const newAnswers = { ...state.answers };
+      if (currentStep && currentStep.keepValuesOnPrevious === false) {
+        delete newAnswers[currentStep.id];
+      }
+      return {
+        ...state,
+        currentStepId: previousStepId,
+        answers: newAnswers,
+        history: state.history.slice(0, -1),
+        status: "running",
+        errors: {}
+      };
+    }
+    case "JUMP": {
+      findStepOrThrow(config, transition.stepId);
+      return {
+        ...state,
+        currentStepId: transition.stepId,
+        history: [...state.history, state.currentStepId],
+        status: "running",
+        errors: {}
+      };
+    }
+    case "CANCEL": {
+      return { ...state, status: "cancelled" };
+    }
+  }
+}
+function findStepOrThrow(config, stepId) {
+  const step = config.steps.find((s) => s.id === stepId);
+  if (!step) {
+    throw new Error(`Step not found: "${stepId}"`);
+  }
+  return step;
+}
+function cleanOrphanedAnswers(config, answers, _fromStepId, _toStepId) {
+  const cleaned = { ...answers };
+  for (const step of config.steps) {
+    if (step.id in cleaned && !isStepVisible(step, cleaned)) {
+      delete cleaned[step.id];
+    }
+  }
+  return cleaned;
+}
+function applyValidationRule(rule, value) {
+  switch (rule.rule) {
+    case "required":
+      return !value.trim() ? rule.message ?? "This field is required" : null;
+    case "minLength":
+      return value.length < rule.value ? rule.message ?? `Must be at least ${String(rule.value)} characters` : null;
+    case "maxLength":
+      return value.length > rule.value ? rule.message ?? `Must be at most ${String(rule.value)} characters` : null;
+    case "pattern": {
+      const regex = new RegExp(rule.value);
+      return !regex.test(value) ? rule.message ?? `Must match pattern: ${rule.value}` : null;
+    }
+    case "min":
+    case "max":
+    default:
+      return null;
+  }
+}
+
+// src/theme.ts
+import chalk from "chalk";
+var DEFAULT_TOKENS = {
+  primary: "#5B9BD5",
+  success: "#6BCB77",
+  error: "#FF6B6B",
+  warning: "#FFD93D",
+  info: "#4D96FF",
+  muted: "#888888",
+  accent: "#C084FC"
+};
+var DEFAULT_ICONS = {
+  step: "\u25CF",
+  stepDone: "\u2713",
+  stepPending: "\u25CB",
+  pointer: "\u203A"
+};
+function resolveTheme(themeConfig) {
+  const tokens = { ...DEFAULT_TOKENS, ...themeConfig?.tokens };
+  const icons = { ...DEFAULT_ICONS, ...themeConfig?.icons };
+  return {
+    primary: chalk.hex(tokens.primary),
+    success: chalk.hex(tokens.success),
+    error: chalk.hex(tokens.error),
+    warning: chalk.hex(tokens.warning),
+    info: chalk.hex(tokens.info),
+    muted: chalk.hex(tokens.muted),
+    accent: chalk.hex(tokens.accent),
+    bold: chalk.bold,
+    icons
+  };
+}
+
+// src/renderers/inquirer.ts
+import {
+  input,
+  select,
+  checkbox,
+  confirm,
+  password,
+  number,
+  search,
+  editor,
+  Separator
+} 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 counter = theme.muted(`Step ${String(stepIndex + 1)}/${String(totalVisible)}`);
+    const stepMessage = theme.muted(`\u2014 ${message}`);
+    console.log(`
+  [${filledBar}${remainingBar}]  ${counter} ${stepMessage}`);
+    if (description) {
+      console.log(`  ${theme.muted(description)}`);
+    }
+  }
+  async renderText(step, state, theme) {
+    const existingAnswer = state.answers[step.id];
+    const defaultValue = typeof existingAnswer === "string" ? existingAnswer : step.default;
+    return input({
+      message: step.message,
+      default: defaultValue,
+      theme: { prefix: { idle: theme.icons.pointer, done: theme.icons.stepDone } }
+    });
+  }
+  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) => {
+      if ("separator" in opt) {
+        return new Separator(opt.separator);
+      }
+      return {
+        name: opt.label,
+        value: opt.value,
+        description: opt.hint,
+        disabled: opt.disabled
+      };
+    });
+    return select({
+      message: step.message,
+      choices,
+      default: defaultValue,
+      pageSize: step.pageSize,
+      loop: step.loop,
+      theme: { prefix: { idle: theme.icons.pointer, done: theme.icons.stepDone } }
+    });
+  }
+  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) => {
+      if ("separator" in opt) {
+        return new Separator(opt.separator);
+      }
+      return {
+        name: opt.label,
+        value: opt.value,
+        checked: previousSelections?.includes(opt.value) ?? false,
+        disabled: opt.disabled
+      };
+    });
+    return checkbox({
+      message: step.message,
+      choices,
+      pageSize: step.pageSize,
+      loop: step.loop,
+      theme: { prefix: { idle: theme.icons.pointer, done: theme.icons.stepDone } }
+    });
+  }
+  async renderConfirm(step, state, theme) {
+    const existingAnswer = state.answers[step.id];
+    const defaultValue = typeof existingAnswer === "boolean" ? existingAnswer : step.default;
+    return confirm({
+      message: step.message,
+      default: defaultValue ?? true,
+      theme: { prefix: { idle: theme.icons.pointer, done: theme.icons.stepDone } }
+    });
+  }
+  async renderPassword(step, _state, theme) {
+    return password({
+      message: step.message,
+      theme: { prefix: { idle: theme.icons.pointer, done: theme.icons.stepDone } }
+    });
+  }
+  async renderNumber(step, state, theme) {
+    const existingAnswer = state.answers[step.id];
+    const defaultValue = typeof existingAnswer === "number" ? existingAnswer : step.default;
+    const result = await number({
+      message: step.message,
+      default: defaultValue,
+      min: step.min,
+      max: step.max,
+      step: step.step,
+      theme: { prefix: { idle: theme.icons.pointer, done: theme.icons.stepDone } }
+    });
+    return result ?? defaultValue ?? 0;
+  }
+  async renderSearch(step, _state, theme) {
+    return search({
+      message: step.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) => ({
+          name: opt.label,
+          value: opt.value,
+          description: opt.hint
+        }));
+      },
+      pageSize: step.pageSize,
+      theme: { prefix: { idle: theme.icons.pointer, done: theme.icons.stepDone } }
+    });
+  }
+  async renderEditor(step, _state, theme) {
+    return editor({
+      message: step.message,
+      default: step.default,
+      theme: { prefix: { idle: theme.icons.pointer, done: theme.icons.stepDone } }
+    });
+  }
+  async renderPath(step, state, theme) {
+    const existingAnswer = state.answers[step.id];
+    const defaultValue = typeof existingAnswer === "string" ? existingAnswer : step.default;
+    return input({
+      message: step.message,
+      default: defaultValue,
+      theme: { prefix: { idle: theme.icons.pointer, done: theme.icons.stepDone } }
+    });
+  }
+  async renderToggle(step, state, theme) {
+    const existingAnswer = state.answers[step.id];
+    const activeLabel = step.active ?? "On";
+    const inactiveLabel = step.inactive ?? "Off";
+    const defaultValue = typeof existingAnswer === "boolean" ? existingAnswer ? activeLabel : inactiveLabel : step.default === true ? activeLabel : inactiveLabel;
+    const result = await select({
+      message: step.message,
+      choices: [
+        { name: activeLabel, value: activeLabel },
+        { name: inactiveLabel, value: inactiveLabel }
+      ],
+      default: defaultValue,
+      theme: { prefix: { idle: theme.icons.pointer, done: theme.icons.stepDone } }
+    });
+    return result === activeLabel;
+  }
+  renderMessage(step, _state, theme) {
+    if (step.description) {
+      console.log(`  ${theme.muted(step.description)}`);
+    }
+    console.log();
+  }
+  renderGroupHeader(group, theme) {
+    console.log(`
+  ${theme.accent("\u2500\u2500")} ${theme.bold(group)} ${theme.accent("\u2500\u2500")}
+`);
+  }
+  renderSummary(answers, steps, theme) {
+    console.log(`
+${theme.muted("\u2500".repeat(40))}`);
+    console.log(`  ${theme.bold("Summary")}
+`);
+    for (const step of steps) {
+      const answer = answers[step.id];
+      if (answer === void 0) continue;
+      const display = Array.isArray(answer) ? answer.map(String).join(", ") : String(answer);
+      console.log(
+        `  ${theme.muted(step.id.padEnd(20))} ${theme.primary(display)}`
+      );
+    }
+    console.log(theme.muted("\u2500".repeat(40)));
+  }
+  clear() {
+    process.stdout.write("\x1B[2J\x1B[0f");
+  }
+};
+
+// src/resolve.ts
+function resolveEnvDefault(value) {
+  if (typeof value !== "string") return value;
+  if (!value.startsWith("$")) return value;
+  const envKey = value.slice(1);
+  return process.env[envKey] ?? value;
+}
+function resolveEnvDefaultNumber(value) {
+  if (typeof value === "number") return value;
+  const resolved = resolveEnvDefault(typeof value === "string" ? value : void 0);
+  if (resolved === void 0) return void 0;
+  const num = Number(resolved);
+  return Number.isNaN(num) ? void 0 : num;
+}
+function resolveEnvDefaultBoolean(value) {
+  if (typeof value === "boolean") return value;
+  const resolved = resolveEnvDefault(typeof value === "string" ? value : void 0);
+  if (resolved === void 0) return void 0;
+  return resolved === "true" || resolved === "1";
+}
+
+// src/template.ts
+function resolveTemplate(template, answers) {
+  return template.replace(/\{\{([^}]+)\}\}/g, (_match, key) => {
+    const trimmedKey = key.trim();
+    if (trimmedKey in answers) {
+      const value = answers[trimmedKey];
+      if (Array.isArray(value)) return value.join(", ");
+      return String(value);
+    }
+    return _match;
+  });
+}
+
+// src/banner.ts
+import figlet from "figlet";
+import gradient from "gradient-string";
+var GRIMOIRE_GRADIENT = gradient(["#C084FC", "#5B9BD5", "#6BCB77"]);
+function renderBanner(name, theme, options) {
+  if (options?.plain) {
+    return `  ${theme.bold(name)}`;
+  }
+  try {
+    const art = figlet.textSync(name, {
+      font: "Small",
+      horizontalLayout: "default"
+    });
+    const lines = art.split("\n").map((line) => `  ${line}`).join("\n");
+    return GRIMOIRE_GRADIENT(lines);
+  } catch {
+    return `  ${theme.bold(name)}`;
+  }
+}
+
+// src/plugins.ts
+var BUILT_IN_STEP_TYPES = /* @__PURE__ */ new Set([
+  "text",
+  "select",
+  "multiselect",
+  "confirm",
+  "password",
+  "number",
+  "search",
+  "editor",
+  "path",
+  "toggle"
+]);
+var pluginStepRegistry = /* @__PURE__ */ new Map();
+function registerPlugin(plugin) {
+  for (const [stepType, stepPlugin] of Object.entries(plugin.steps)) {
+    if (BUILT_IN_STEP_TYPES.has(stepType)) {
+      throw new Error(`Cannot override built-in step type "${stepType}"`);
+    }
+    if (pluginStepRegistry.has(stepType)) {
+      throw new Error(`Step type "${stepType}" is already registered`);
+    }
+    pluginStepRegistry.set(stepType, stepPlugin);
+  }
+}
+function getPluginStep(stepType) {
+  return pluginStepRegistry.get(stepType);
+}
+function clearPlugins() {
+  pluginStepRegistry.clear();
+}
+
+// src/cache.ts
+import { mkdirSync, readFileSync as readFileSync2, writeFileSync, unlinkSync, readdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var DEFAULT_CACHE_DIR = join(homedir(), ".config", "grimoire", "cache");
+function slugify(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function getCacheDir(customDir) {
+  return customDir ?? DEFAULT_CACHE_DIR;
+}
+function getCacheFilePath(wizardName, customDir) {
+  return join(getCacheDir(customDir), `${slugify(wizardName)}.json`);
+}
+function loadCachedAnswers(wizardName, customDir) {
+  try {
+    const filePath = getCacheFilePath(wizardName, customDir);
+    const raw = readFileSync2(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+      return parsed;
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+function saveCachedAnswers(wizardName, answers, customDir) {
+  try {
+    const dir = getCacheDir(customDir);
+    mkdirSync(dir, { recursive: true });
+    const filePath = getCacheFilePath(wizardName, customDir);
+    writeFileSync(filePath, JSON.stringify(answers, null, 2) + "\n", "utf-8");
+  } catch {
+  }
+}
+function clearCache(wizardName, customDir) {
+  try {
+    const dir = getCacheDir(customDir);
+    if (wizardName) {
+      const filePath = getCacheFilePath(wizardName, customDir);
+      unlinkSync(filePath);
+    } else {
+      const files = readdirSync(dir);
+      for (const file of files) {
+        if (file.endsWith(".json")) {
+          unlinkSync(join(dir, file));
+        }
+      }
+    }
+  } catch {
+  }
+}
+
+// src/mru.ts
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync } from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+var MRU_DIR = join2(homedir2(), ".config", "grimoire", "mru");
+function getMruFilePath(wizardName) {
+  const safeName = wizardName.replace(/[^a-zA-Z0-9_-]/g, "_");
+  return join2(MRU_DIR, `${safeName}.json`);
+}
+function loadMruData(wizardName) {
+  const filePath = getMruFilePath(wizardName);
+  try {
+    if (!existsSync(filePath)) {
+      return {};
+    }
+    const raw = readFileSync3(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      return {};
+    }
+    return parsed;
+  } catch {
+    return {};
+  }
+}
+function saveMruData(wizardName, data) {
+  const filePath = getMruFilePath(wizardName);
+  try {
+    mkdirSync2(MRU_DIR, { recursive: true });
+    writeFileSync2(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+  } catch {
+  }
+}
+function recordSelection(wizardName, stepId, value) {
+  const data = loadMruData(wizardName);
+  const stepData = data[stepId] ?? {};
+  const values = Array.isArray(value) ? value : [value];
+  for (const v of values) {
+    stepData[v] = (stepData[v] ?? 0) + 1;
+  }
+  data[stepId] = stepData;
+  saveMruData(wizardName, data);
+}
+function getOrderedOptions(wizardName, stepId, options) {
+  const data = loadMruData(wizardName);
+  const stepData = data[stepId] ?? {};
+  if (Object.keys(stepData).length === 0) {
+    return options;
+  }
+  const separatorIndices = /* @__PURE__ */ new Map();
+  const selectableOptions = [];
+  for (let i = 0; i < options.length; i++) {
+    const opt = options[i];
+    if ("separator" in opt) {
+      separatorIndices.set(i, opt);
+    } else {
+      selectableOptions.push(opt);
+    }
+  }
+  const sorted = [...selectableOptions].sort((a, b) => {
+    if (!("value" in a) || !("value" in b)) return 0;
+    const countA = stepData[a.value] ?? 0;
+    const countB = stepData[b.value] ?? 0;
+    return countB - countA;
+  });
+  const result = [];
+  let sortedIndex = 0;
+  for (let i = 0; i < options.length; i++) {
+    const sep = separatorIndices.get(i);
+    if (sep) {
+      result.push(sep);
+    } else {
+      const next = sorted[sortedIndex];
+      if (next) {
+        result.push(next);
+      }
+      sortedIndex++;
+    }
+  }
+  return result;
+}
+
+// src/runner.ts
+function runPreFlightChecks(checks, theme) {
+  for (const check of checks) {
+    try {
+      execSync(check.run, { stdio: "pipe" });
+      console.log(`  ${theme.success("\u2713")} ${check.name}`);
+    } catch {
+      console.log(`  ${theme.error("\u2717")} ${check.name}: ${check.message}`);
+      throw new Error(`Pre-flight check failed: ${check.name} \u2014 ${check.message}`);
+    }
+  }
+  console.log();
+}
+function getMockValue(step, mockAnswers) {
+  if (step.id in mockAnswers) {
+    return mockAnswers[step.id];
+  }
+  if (step.type === "message") {
+    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`
+  );
+}
+function getStepDefault(step) {
+  switch (step.type) {
+    case "text":
+    case "select":
+    case "search":
+    case "editor":
+    case "path":
+      return step.default;
+    case "number":
+      return step.default;
+    case "confirm":
+    case "toggle":
+      return step.default;
+    case "multiselect":
+      return step.default;
+    case "password":
+    case "message":
+      return void 0;
+  }
+}
+async function runWizard(config, options) {
+  const renderer = options?.renderer ?? new InquirerRenderer();
+  const theme = resolveTheme(config.theme);
+  const mockAnswers = options?.mockAnswers;
+  const isMock = mockAnswers !== void 0;
+  const quiet = options?.quiet ?? isMock;
+  const cacheEnabled = !isMock && options?.cache !== false;
+  const cacheDir = typeof options?.cache === "object" ? options.cache.dir : void 0;
+  const mruEnabled = !isMock && options?.mru !== false;
+  let state = createWizardState(config);
+  const cachedAnswers = cacheEnabled ? loadCachedAnswers(config.meta.name, cacheDir) : void 0;
+  const userPlugins = options?.plugins;
+  if (userPlugins) {
+    for (const plugin of userPlugins) {
+      registerPlugin(plugin);
+    }
+  }
+  try {
+    if (!isMock && config.checks && config.checks.length > 0) {
+      runPreFlightChecks(config.checks, theme);
+    }
+    if (!quiet) {
+      printWizardHeader(config, theme, options?.plain);
+    }
+    let previousGroup;
+    while (state.status === "running") {
+      const visibleSteps = getVisibleSteps(config, state.answers);
+      const currentStep = config.steps.find((s) => s.id === state.currentStepId);
+      if (!currentStep) {
+        throw new Error(`Current step not found: "${state.currentStepId}"`);
+      }
+      if (!isMock) {
+        if (currentStep.group !== void 0 && currentStep.group !== previousGroup) {
+          const resolvedGroup = resolveTemplate(currentStep.group, state.answers);
+          renderer.renderGroupHeader(resolvedGroup, theme);
+        }
+        previousGroup = currentStep.group;
+        const stepIndex = visibleSteps.findIndex((s) => s.id === state.currentStepId);
+        const resolvedMessage = resolveTemplate(currentStep.message, state.answers);
+        const resolvedDescription = currentStep.description ? resolveTemplate(currentStep.description, state.answers) : void 0;
+        renderer.renderStepHeader(stepIndex, visibleSteps.length, resolvedMessage, theme, resolvedDescription);
+      }
+      if (options?.onBeforeStep) {
+        await options.onBeforeStep(currentStep.id, currentStep, state);
+      }
+      const pluginStep = getPluginStep(currentStep.type);
+      const resolvedStep = pluginStep ? currentStep : resolveStepDefaults(currentStep, cachedAnswers);
+      const withTemplate = options?.templateAnswers ? applyTemplateDefaults(resolvedStep, options.templateAnswers) : resolvedStep;
+      const templatedStep = resolveStepTemplates(withTemplate, state.answers);
+      const mruStep = mruEnabled ? applyMruOrdering(templatedStep, config.meta.name) : templatedStep;
+      try {
+        const value = isMock ? getMockValue(mruStep, mockAnswers) : pluginStep ? await pluginStep.render(toStepRecord(mruStep), state, theme) : await renderStep(renderer, mruStep, state, theme);
+        if (pluginStep?.validate) {
+          const pluginError = pluginStep.validate(value, toStepRecord(templatedStep));
+          if (pluginError) {
+            if (isMock) {
+              throw new Error(
+                `Mock mode: validation failed for step "${currentStep.id}": ${pluginError}`
+              );
+            }
+            console.log(theme.error(`
+  ${pluginError}
+`));
+            continue;
+          }
+        }
+        const nextState = wizardReducer(state, { type: "NEXT", value }, config);
+        if (nextState.errors[currentStep.id]) {
+          const errorMsg = resolveTemplate(nextState.errors[currentStep.id] ?? "", state.answers);
+          if (isMock) {
+            throw new Error(
+              `Mock mode: validation failed for step "${currentStep.id}": ${errorMsg}`
+            );
+          }
+          console.log(theme.error(`
+  ${errorMsg}
+`));
+          state = { ...nextState, errors: {} };
+          continue;
+        }
+        if (!isMock && options?.asyncValidate) {
+          const asyncError = await options.asyncValidate(currentStep.id, value, nextState.answers);
+          if (asyncError !== null) {
+            console.log(theme.error(`
+  ${asyncError}
+`));
+            state = { ...nextState, errors: {} };
+            continue;
+          }
+        }
+        if (options?.onAfterStep) {
+          await options.onAfterStep(currentStep.id, value, nextState);
+        }
+        state = nextState;
+        if (mruEnabled && isSelectLikeStep(currentStep.type)) {
+          recordSelection(config.meta.name, currentStep.id, value);
+        }
+        options?.onStepComplete?.(currentStep.id, value, state);
+      } catch (error) {
+        if (!isMock && isUserCancel(error)) {
+          state = wizardReducer(state, { type: "CANCEL" }, config);
+          options?.onCancel?.(state);
+          if (!quiet) {
+            console.log(theme.warning("\n  Wizard cancelled.\n"));
+          }
+          return state.answers;
+        }
+        throw error;
+      }
+    }
+    if (state.status === "done" && !quiet) {
+      renderer.renderSummary(state.answers, config.steps, theme);
+    }
+    if (state.status === "done" && config.actions && config.actions.length > 0 && !isMock) {
+      await executeActions(config.actions, state.answers, theme);
+    }
+    if (state.status === "done" && cacheEnabled) {
+      const passwordStepIds = new Set(
+        config.steps.filter((s) => s.type === "password").map((s) => s.id)
+      );
+      const answersToCache = {};
+      for (const [key, value] of Object.entries(state.answers)) {
+        if (!passwordStepIds.has(key)) {
+          answersToCache[key] = value;
+        }
+      }
+      saveCachedAnswers(config.meta.name, answersToCache, cacheDir);
+    }
+    return state.answers;
+  } finally {
+    if (userPlugins) {
+      clearPlugins();
+    }
+  }
+}
+function toStepRecord(step) {
+  const record = {};
+  for (const [key, val] of Object.entries(step)) {
+    record[key] = val;
+  }
+  return record;
+}
+function renderStep(renderer, step, state, theme) {
+  switch (step.type) {
+    case "text":
+      return renderer.renderText(step, state, theme);
+    case "select":
+      return renderer.renderSelect(step, state, theme);
+    case "multiselect":
+      return renderer.renderMultiSelect(step, state, theme);
+    case "confirm":
+      return renderer.renderConfirm(step, state, theme);
+    case "password":
+      return renderer.renderPassword(step, state, theme);
+    case "number":
+      return renderer.renderNumber(step, state, theme);
+    case "search":
+      return renderer.renderSearch(step, state, theme);
+    case "editor":
+      return renderer.renderEditor(step, state, theme);
+    case "path":
+      return renderer.renderPath(step, state, theme);
+    case "toggle":
+      return renderer.renderToggle(step, state, theme);
+    case "message":
+      renderer.renderMessage(step, state, theme);
+      return Promise.resolve(true);
+  }
+}
+function resolveStepDefaults(step, cachedAnswers) {
+  switch (step.type) {
+    case "text": {
+      const envResolved = resolveEnvDefault(step.default);
+      const fallback = envResolved ?? getCachedDefault(step.id, cachedAnswers);
+      return { ...step, default: fallback };
+    }
+    case "search": {
+      const envResolved = resolveEnvDefault(step.default);
+      const fallback = envResolved ?? getCachedDefault(step.id, cachedAnswers);
+      return { ...step, default: fallback };
+    }
+    case "editor": {
+      const envResolved = resolveEnvDefault(step.default);
+      const fallback = envResolved ?? getCachedDefault(step.id, cachedAnswers);
+      return { ...step, default: fallback };
+    }
+    case "path": {
+      const envResolved = resolveEnvDefault(step.default);
+      const fallback = envResolved ?? getCachedDefault(step.id, cachedAnswers);
+      return { ...step, default: fallback };
+    }
+    case "select": {
+      const envResolved = resolveEnvDefault(step.default);
+      const fallback = envResolved ?? getCachedDefault(step.id, cachedAnswers);
+      return { ...step, default: fallback };
+    }
+    case "number": {
+      const resolved = resolveEnvDefaultNumber(step.default);
+      const fallback = resolved ?? getCachedDefault(step.id, cachedAnswers);
+      return { ...step, default: fallback };
+    }
+    case "confirm": {
+      const resolved = resolveEnvDefaultBoolean(step.default);
+      const fallback = resolved ?? getCachedDefault(step.id, cachedAnswers);
+      return { ...step, default: fallback };
+    }
+    case "toggle": {
+      const resolved = resolveEnvDefaultBoolean(step.default);
+      const fallback = resolved ?? getCachedDefault(step.id, cachedAnswers);
+      return { ...step, default: fallback };
+    }
+    case "multiselect": {
+      const fallback = step.default ?? getCachedDefault(step.id, cachedAnswers);
+      return { ...step, default: fallback };
+    }
+    case "password":
+    case "message":
+      return step;
+  }
+}
+function getCachedDefault(stepId, cachedAnswers) {
+  if (!cachedAnswers || !(stepId in cachedAnswers)) return void 0;
+  return cachedAnswers[stepId];
+}
+function applyTemplateDefaults(step, templateAnswers) {
+  if (!(step.id in templateAnswers)) return step;
+  if (step.type === "password" || step.type === "message") return step;
+  const value = templateAnswers[step.id];
+  switch (step.type) {
+    case "text":
+    case "select":
+    case "search":
+    case "editor":
+    case "path":
+      return { ...step, default: typeof value === "string" ? value : step.default };
+    case "number":
+      return { ...step, default: typeof value === "number" ? value : step.default };
+    case "confirm":
+    case "toggle":
+      return { ...step, default: typeof value === "boolean" ? value : step.default };
+    case "multiselect":
+      return { ...step, default: Array.isArray(value) ? value : step.default };
+  }
+}
+function isSelectLikeStep(type) {
+  return type === "select" || type === "multiselect" || type === "search";
+}
+function applyMruOrdering(step, wizardName) {
+  if (step.type === "select") {
+    return { ...step, options: getOrderedOptions(wizardName, step.id, step.options) };
+  }
+  if (step.type === "multiselect") {
+    return { ...step, options: getOrderedOptions(wizardName, step.id, step.options) };
+  }
+  if (step.type === "search") {
+    return { ...step, options: getOrderedOptions(wizardName, step.id, step.options) };
+  }
+  return step;
+}
+function resolveChoiceTemplates(options, answers) {
+  return options.map((opt) => {
+    if ("separator" in opt) return opt;
+    return {
+      ...opt,
+      label: resolveTemplate(opt.label, answers),
+      hint: opt.hint ? resolveTemplate(opt.hint, answers) : void 0
+    };
+  });
+}
+function resolveStepTemplates(step, answers) {
+  switch (step.type) {
+    case "text":
+      return {
+        ...step,
+        placeholder: step.placeholder ? resolveTemplate(step.placeholder, answers) : void 0,
+        default: step.default ? resolveTemplate(step.default, answers) : void 0,
+        description: step.description ? resolveTemplate(step.description, answers) : void 0
+      };
+    case "select":
+      return {
+        ...step,
+        options: resolveChoiceTemplates(step.options, answers),
+        description: step.description ? resolveTemplate(step.description, answers) : void 0
+      };
+    case "multiselect":
+      return {
+        ...step,
+        options: resolveChoiceTemplates(step.options, answers),
+        description: step.description ? resolveTemplate(step.description, answers) : void 0
+      };
+    case "search":
+      return {
+        ...step,
+        placeholder: step.placeholder ? resolveTemplate(step.placeholder, answers) : void 0,
+        options: resolveChoiceTemplates(step.options, answers),
+        description: step.description ? resolveTemplate(step.description, answers) : void 0
+      };
+    case "path":
+      return {
+        ...step,
+        placeholder: step.placeholder ? resolveTemplate(step.placeholder, answers) : void 0,
+        default: step.default ? resolveTemplate(step.default, answers) : void 0,
+        description: step.description ? resolveTemplate(step.description, answers) : void 0
+      };
+    case "editor":
+      return {
+        ...step,
+        default: step.default ? resolveTemplate(step.default, answers) : void 0,
+        description: step.description ? resolveTemplate(step.description, answers) : void 0
+      };
+    case "password":
+    case "number":
+    case "confirm":
+    case "toggle":
+    case "message":
+      return {
+        ...step,
+        description: step.description ? resolveTemplate(step.description, answers) : void 0
+      };
+  }
+}
+async function executeActions(actions, answers, theme) {
+  console.log(`
+  ${theme.bold("Running actions...")}
+`);
+  for (const action of actions) {
+    if (action.when && !evaluateCondition(action.when, answers)) {
+      continue;
+    }
+    const resolvedCommand = resolveTemplate(action.run, answers);
+    const resolvedName = action.name ? resolveTemplate(action.name, answers) : void 0;
+    const label = resolvedName ?? resolvedCommand;
+    try {
+      execSync(resolvedCommand, { stdio: "pipe" });
+      console.log(`  ${theme.success("\u2713")} ${label}`);
+    } catch {
+      console.log(`  ${theme.error("\u2717")} ${label}`);
+      throw new Error(`Action failed: ${label}`);
+    }
+  }
+  console.log();
+}
+function printWizardHeader(config, theme, plain) {
+  console.log();
+  console.log(renderBanner(config.meta.name, theme, { plain }));
+  if (config.meta.description) {
+    console.log(`  ${theme.muted(config.meta.description)}`);
+  }
+  console.log();
+}
+function isUserCancel(error) {
+  if (error instanceof Error) {
+    return error.message.includes("User force closed") || error.name === "ExitPromptError";
+  }
+  return false;
+}
+
+// src/scaffolder.ts
+import { input as input2, select as select2, confirm as confirm2, number as number2 } from "@inquirer/prompts";
+import { stringify } from "yaml";
+import { writeFileSync as writeFileSync3 } from "fs";
+import { relative } from "path";
+var STEP_TYPE_CHOICES = [
+  { name: "text", value: "text" },
+  { name: "select", value: "select" },
+  { name: "multiselect", value: "multiselect" },
+  { name: "confirm", value: "confirm" },
+  { name: "password", value: "password" },
+  { name: "number", value: "number" },
+  { name: "search", value: "search" },
+  { name: "editor", value: "editor" },
+  { name: "path", value: "path" },
+  { name: "toggle", value: "toggle" }
+];
+var TYPES_WITH_OPTIONS = /* @__PURE__ */ new Set(["select", "multiselect", "search"]);
+function isUserCancel2(error) {
+  if (error instanceof Error) {
+    return error.message.includes("User force closed") || error.name === "ExitPromptError";
+  }
+  return false;
+}
+async function scaffoldWizard(outputPath) {
+  try {
+    const wizardName = await input2({
+      message: "Wizard name",
+      validate: (val) => val.trim().length > 0 || "Name is required"
+    });
+    const description = await input2({
+      message: "Description (optional)"
+    });
+    const rawStepCount = await number2({
+      message: "How many steps?",
+      default: 3,
+      min: 1,
+      max: 20
+    });
+    const stepCount = rawStepCount ?? 3;
+    const steps = [];
+    for (let i = 0; i < stepCount; i++) {
+      console.log(`
+  Step ${String(i + 1)} of ${String(stepCount)}`);
+      const stepId = await input2({
+        message: "Step ID",
+        validate: (val) => /^[a-z][a-z0-9-]*$/.test(val) || "Must be lowercase, start with a letter, hyphens only (e.g., my-step)"
+      });
+      const stepType = await select2({
+        message: "Step type",
+        choices: STEP_TYPE_CHOICES
+      });
+      const stepMessage = await input2({
+        message: "Prompt message",
+        validate: (val) => val.trim().length > 0 || "Message is required"
+      });
+      const step = {
+        id: stepId,
+        type: stepType,
+        message: stepMessage
+      };
+      if (TYPES_WITH_OPTIONS.has(stepType)) {
+        const rawOptions = await input2({
+          message: "Options (comma-separated values)",
+          validate: (val) => val.split(",").some((v) => v.trim().length > 0) || "At least one option is required"
+        });
+        step.options = rawOptions.split(",").map((v) => v.trim()).filter((v) => v.length > 0).map((v) => ({
+          value: v,
+          label: v.charAt(0).toUpperCase() + v.slice(1)
+        }));
+      }
+      const isRequired = await confirm2({
+        message: "Is this a required field?",
+        default: true
+      });
+      if (!isRequired) {
+        step.required = false;
+      }
+      steps.push(step);
+    }
+    const format = await select2({
+      message: "Output format",
+      choices: [
+        { name: "JSON", value: "json" },
+        { name: "YAML", value: "yaml" },
+        { name: "ENV", value: "env" }
+      ]
+    });
+    const outputFilePath = await input2({
+      message: "Output file path (optional)"
+    });
+    const wantTheme = await confirm2({
+      message: "Do you want a theme?",
+      default: false
+    });
+    let primaryColor = "";
+    if (wantTheme) {
+      primaryColor = await input2({
+        message: "Primary color (hex)",
+        default: "#5B9BD5",
+        validate: (val) => /^#[0-9A-Fa-f]{6}$/.test(val) || "Must be a valid hex color (e.g., #5B9BD5)"
+      });
+    }
+    const meta = { name: wizardName };
+    if (description.length > 0) {
+      meta.description = description;
+    }
+    const outputConfig = { format };
+    if (outputFilePath.length > 0) {
+      outputConfig.path = outputFilePath;
+    }
+    const config = {
+      meta,
+      steps,
+      output: outputConfig
+    };
+    if (wantTheme) {
+      config.theme = { tokens: { primary: primaryColor } };
+    }
+    const yamlContent = stringify(config);
+    writeFileSync3(outputPath, yamlContent, "utf-8");
+    const displayPath = relative(process.cwd(), outputPath);
+    console.log(`
+  \u2713 Created wizard config: ${outputPath}`);
+    console.log(`  Run it with: grimoire run ${displayPath}
+`);
+  } catch (error) {
+    if (isUserCancel2(error)) {
+      console.log("\n  Wizard creation cancelled.\n");
+      return;
+    }
+    throw error;
+  }
+}
+
+// src/completions.ts
+function bashCompletion() {
+  return `_grimoire() {
+  local cur prev words cword
+  COMPREPLY=()
+  cur="\${COMP_WORDS[COMP_CWORD]}"
+  prev="\${COMP_WORDS[COMP_CWORD-1]}"
+  words=("\${COMP_WORDS[@]}")
+  cword=\${COMP_CWORD}
+
+  # Get the subcommand (first non-option argument)
+  local subcommand=""
+  local i
+  for ((i = 1; i < cword; i++)); do
+    if [[ "\${words[i]}" != -* ]]; then
+      subcommand="\${words[i]}"
+      break
+    fi
+  done
+
+  # Complete subcommands
+  if [[ \${cword} -eq 1 ]]; then
+    COMPREPLY=($(compgen -W "run validate create demo completion" -- "\${cur}"))
+    return 0
+  fi
+
+  # Complete shell argument for completion command
+  if [[ "\${subcommand}" == "completion" ]]; then
+    if [[ \${cword} -eq 2 ]]; then
+      COMPREPLY=($(compgen -W "bash zsh fish" -- "\${cur}"))
+    fi
+    return 0
+  fi
+
+  # Complete flags for run command
+  if [[ "\${subcommand}" == "run" ]]; then
+    if [[ "\${cur}" == -* ]]; then
+      COMPREPLY=($(compgen -W "-o --output -f --format -q --quiet --dry-run --mock --json" -- "\${cur}"))
+    elif [[ "\${prev}" == "-f" ]] || [[ "\${prev}" == "--format" ]]; then
+      COMPREPLY=($(compgen -W "json yaml env" -- "\${cur}"))
+    elif [[ "\${prev}" == "-o" ]] || [[ "\${prev}" == "--output" ]]; then
+      COMPREPLY=($(compgen -f -- "\${cur}"))
+    elif [[ "\${prev}" == "--mock" ]]; then
+      COMPREPLY=()
+    else
+      # Complete config file path
+      COMPREPLY=($(compgen -f -- "\${cur}"))
+    fi
+    return 0
+  fi
+
+  # Complete flags for validate command
+  if [[ "\${subcommand}" == "validate" ]]; then
+    if [[ "\${cur}" == -* ]]; then
+      COMPREPLY=()
+    else
+      # Complete config file path
+      COMPREPLY=($(compgen -f -- "\${cur}"))
+    fi
+    return 0
+  fi
+
+  # Complete flags for create command
+  if [[ "\${subcommand}" == "create" ]]; then
+    if [[ "\${cur}" == -* ]]; then
+      COMPREPLY=()
+    else
+      # Complete output file path
+      COMPREPLY=($(compgen -f -- "\${cur}"))
+    fi
+    return 0
+  fi
+
+  # Complete flags for demo command
+  if [[ "\${subcommand}" == "demo" ]]; then
+    COMPREPLY=()
+    return 0
+  fi
+
+  return 0
+}
+
+complete -o bashdefault -o default -o nospace -F _grimoire grimoire
+`;
+}
+function zshCompletion() {
+  return `#compdef grimoire
+
+_grimoire() {
+  local -a subcommands
+  subcommands=(
+    'run:Run a wizard from a config file'
+    'validate:Validate a wizard config file without running it'
+    'create:Interactively scaffold a new wizard config file'
+    'demo:Run a demo wizard showcasing all step types'
+    'completion:Output shell completion script'
+  )
+
+  local -a run_flags
+  run_flags=(
+    '-o+[Write answers to file]:output file:_files'
+    '--output+[Write answers to file]:output file:_files'
+    '-f+[Output format]:format:(json yaml env)'
+    '--format+[Output format]:format:(json yaml env)'
+    '-q[Suppress header and summary output]'
+    '--quiet[Suppress header and summary output]'
+    '--dry-run[Show step plan without running the wizard]'
+    '--mock+[Run wizard with preset answers]:json string:'
+    '--json[Output structured JSON result to stdout]'
+  )
+
+  local -a completion_shells
+  completion_shells=(
+    'bash:Bash shell'
+    'zsh:Zsh shell'
+    'fish:Fish shell'
+  )
+
+  local context state line
+
+  _arguments -C     '1: :->command'     '*::args:->args'
+
+  case $state in
+    command)
+      _describe 'command' subcommands
+      ;;
+    args)
+      case \${words[2]} in
+        run)
+          _arguments             $run_flags             '1:config file:_files'
+          ;;
+        validate)
+          _arguments '1:config file:_files'
+          ;;
+        create)
+          _arguments '1:output file:_files'
+          ;;
+        demo)
+          ;;
+        completion)
+          _describe 'shell' completion_shells
+          ;;
+      esac
+      ;;
+  esac
+}
+
+_grimoire
+`;
+}
+function fishCompletion() {
+  return `# Fish completion for grimoire
+
+# Subcommands
+complete -c grimoire -f -n "__fish_use_subcommand_from_list" -a "run" -d "Run a wizard from a config file"
+complete -c grimoire -f -n "__fish_use_subcommand_from_list" -a "validate" -d "Validate a wizard config file without running it"
+complete -c grimoire -f -n "__fish_use_subcommand_from_list" -a "create" -d "Interactively scaffold a new wizard config file"
+complete -c grimoire -f -n "__fish_use_subcommand_from_list" -a "demo" -d "Run a demo wizard showcasing all step types"
+complete -c grimoire -f -n "__fish_use_subcommand_from_list" -a "completion" -d "Output shell completion script"
+
+# run command flags
+complete -c grimoire -n "__fish_seen_subcommand_from run" -s o -l output -d "Write answers to file" -r
+complete -c grimoire -n "__fish_seen_subcommand_from run" -s f -l format -d "Output format" -x -a "json yaml env"
+complete -c grimoire -n "__fish_seen_subcommand_from run" -s q -l quiet -d "Suppress header and summary output"
+complete -c grimoire -n "__fish_seen_subcommand_from run" -l dry-run -d "Show step plan without running the wizard"
+complete -c grimoire -n "__fish_seen_subcommand_from run" -l mock -d "Run wizard with preset answers (JSON string)" -r
+complete -c grimoire -n "__fish_seen_subcommand_from run" -l json -d "Output structured JSON result to stdout"
+
+# completion command shells
+complete -c grimoire -n "__fish_seen_subcommand_from completion" -f -a "bash" -d "Bash shell"
+complete -c grimoire -n "__fish_seen_subcommand_from completion" -f -a "zsh" -d "Zsh shell"
+complete -c grimoire -n "__fish_seen_subcommand_from completion" -f -a "fish" -d "Fish shell"
+`;
+}
+
+// src/templates.ts
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync4, unlinkSync as unlinkSync2, readdirSync as readdirSync2, existsSync as existsSync2 } from "fs";
+import { join as join3 } from "path";
+import { homedir as homedir3 } from "os";
+var TEMPLATES_DIR = join3(homedir3(), ".config", "grimoire", "templates");
+function getWizardTemplateDir(wizardName) {
+  return join3(TEMPLATES_DIR, slugify(wizardName));
+}
+function getTemplateFilePath(wizardName, templateName) {
+  return join3(getWizardTemplateDir(wizardName), `${slugify(templateName)}.json`);
+}
+function loadTemplate(wizardName, templateName) {
+  try {
+    const filePath = getTemplateFilePath(wizardName, templateName);
+    const raw = readFileSync4(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+      return parsed;
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+function listTemplates(wizardName) {
+  try {
+    const dir = getWizardTemplateDir(wizardName);
+    if (!existsSync2(dir)) return [];
+    return readdirSync2(dir).filter((f) => f.endsWith(".json")).map((f) => f.replace(/\.json$/, ""));
+  } catch {
+    return [];
+  }
+}
+function deleteTemplate(wizardName, templateName) {
+  try {
+    const filePath = getTemplateFilePath(wizardName, templateName);
+    unlinkSync2(filePath);
+  } catch {
+  }
+}
+
+// src/renderers/ink.ts
+import {
+  input as input3,
+  select as select3,
+  checkbox as checkbox2,
+  confirm as confirm3,
+  password as password2,
+  number as number3,
+  search as search2,
+  editor as editor2,
+  Separator as Separator2
+} from "@inquirer/prompts";
+function boxLine(text, theme) {
+  const line = "\u2500".repeat(Math.max(0, 40 - text.length));
+  return `${theme.accent("\u250C\u2500")} ${theme.bold(text)} ${theme.accent(`${line}\u2510`)}`;
+}
+var InkRenderer = class {
+  renderStepHeader(stepIndex, totalVisible, message, theme, description) {
+    const barWidth = 30;
+    const progress = totalVisible > 0 ? stepIndex / totalVisible : 0;
+    const filledCount = Math.round(progress * barWidth);
+    const remainingCount = barWidth - filledCount;
+    const filledBar = theme.success("\u2593".repeat(filledCount));
+    const remainingBar = theme.muted("\u2591".repeat(remainingCount));
+    const pct = `${String(Math.round(progress * 100))}%`;
+    const counter = theme.muted(`Step ${String(stepIndex + 1)}/${String(totalVisible)}`);
+    console.log();
+    console.log(`  ${theme.accent("\u250C")} ${counter} ${theme.muted(pct)}`);
+    console.log(`  ${theme.accent("\u2502")} [${filledBar}${remainingBar}]`);
+    console.log(`  ${theme.accent("\u2514\u2500")} ${theme.primary(message)}`);
+    if (description) {
+      console.log(`     ${theme.muted(description)}`);
+    }
+  }
+  async renderText(step, state, theme) {
+    const existingAnswer = state.answers[step.id];
+    const defaultValue = typeof existingAnswer === "string" ? existingAnswer : step.default;
+    return input3({
+      message: step.message,
+      default: defaultValue,
+      theme: { prefix: { idle: theme.icons.pointer, done: theme.icons.stepDone } }
+    });
+  }
+  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) => {
+      if ("separator" in opt) {
+        return new Separator2(opt.separator);
+      }
+      return {
+        name: opt.label,
+        value: opt.value,
+        description: opt.hint,
+        disabled: opt.disabled
+      };
+    });
+    return select3({
+      message: step.message,
+      choices,
+      default: defaultValue,
+      pageSize: step.pageSize,
+      loop: step.loop,
+      theme: { prefix: { idle: theme.icons.pointer, done: theme.icons.stepDone } }
+    });
+  }
+  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) => {
+      if ("separator" in opt) {
+        return new Separator2(opt.separator);
+      }
+      return {
+        name: opt.label,
+        value: opt.value,
+        checked: previousSelections?.includes(opt.value) ?? false,
+        disabled: opt.disabled
+      };
+    });
+    return checkbox2({
+      message: step.message,
+      choices,
+      pageSize: step.pageSize,
+      loop: step.loop,
+      theme: { prefix: { idle: theme.icons.pointer, done: theme.icons.stepDone } }
+    });
+  }
+  async renderConfirm(step, state, theme) {
+    const existingAnswer = state.answers[step.id];
+    const defaultValue = typeof existingAnswer === "boolean" ? existingAnswer : step.default;
+    return confirm3({
+      message: step.message,
+      default: defaultValue ?? true,
+      theme: { prefix: { idle: theme.icons.pointer, done: theme.icons.stepDone } }
+    });
+  }
+  async renderPassword(step, _state, theme) {
+    return password2({
+      message: step.message,
+      theme: { prefix: { idle: theme.icons.pointer, done: theme.icons.stepDone } }
+    });
+  }
+  async renderNumber(step, state, theme) {
+    const existingAnswer = state.answers[step.id];
+    const defaultValue = typeof existingAnswer === "number" ? existingAnswer : step.default;
+    const result = await number3({
+      message: step.message,
+      default: defaultValue,
+      min: step.min,
+      max: step.max,
+      step: step.step,
+      theme: { prefix: { idle: theme.icons.pointer, done: theme.icons.stepDone } }
+    });
+    return result ?? defaultValue ?? 0;
+  }
+  async renderSearch(step, _state, theme) {
+    return search2({
+      message: step.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) => ({
+          name: opt.label,
+          value: opt.value,
+          description: opt.hint
+        }));
+      },
+      pageSize: step.pageSize,
+      theme: { prefix: { idle: theme.icons.pointer, done: theme.icons.stepDone } }
+    });
+  }
+  async renderEditor(step, _state, theme) {
+    return editor2({
+      message: step.message,
+      default: step.default,
+      theme: { prefix: { idle: theme.icons.pointer, done: theme.icons.stepDone } }
+    });
+  }
+  async renderPath(step, state, theme) {
+    const existingAnswer = state.answers[step.id];
+    const defaultValue = typeof existingAnswer === "string" ? existingAnswer : step.default;
+    return input3({
+      message: step.message,
+      default: defaultValue,
+      theme: { prefix: { idle: theme.icons.pointer, done: theme.icons.stepDone } }
+    });
+  }
+  async renderToggle(step, state, theme) {
+    const existingAnswer = state.answers[step.id];
+    const activeLabel = step.active ?? "On";
+    const inactiveLabel = step.inactive ?? "Off";
+    const defaultValue = typeof existingAnswer === "boolean" ? existingAnswer ? activeLabel : inactiveLabel : step.default === true ? activeLabel : inactiveLabel;
+    const result = await select3({
+      message: step.message,
+      choices: [
+        { name: activeLabel, value: activeLabel },
+        { name: inactiveLabel, value: inactiveLabel }
+      ],
+      default: defaultValue,
+      theme: { prefix: { idle: theme.icons.pointer, done: theme.icons.stepDone } }
+    });
+    return result === activeLabel;
+  }
+  renderMessage(step, _state, theme) {
+    if (step.description) {
+      console.log(`  ${theme.muted(step.description)}`);
+    }
+    console.log();
+  }
+  renderGroupHeader(group, theme) {
+    console.log();
+    console.log(`  ${boxLine(group, theme)}`);
+    console.log();
+  }
+  renderSummary(answers, steps, theme) {
+    const divider = theme.accent("\u2500".repeat(50));
+    console.log();
+    console.log(`  ${divider}`);
+    console.log(`  ${theme.accent("\u2502")} ${theme.bold("Summary")}`);
+    console.log(`  ${divider}`);
+    for (const step of steps) {
+      const answer = answers[step.id];
+      if (answer === void 0) continue;
+      const display = Array.isArray(answer) ? answer.map(String).join(", ") : String(answer);
+      const label = theme.muted(step.id.padEnd(24));
+      const value = theme.primary(display);
+      console.log(`  ${theme.accent("\u2502")} ${label} ${value}`);
+    }
+    console.log(`  ${divider}`);
+  }
+  clear() {
+    process.stdout.write("\x1B[2J\x1B[0f");
+  }
+};
+
+// src/cli.ts
+import { writeFileSync as writeFileSync5 } from "fs";
+import { resolve as resolve2 } from "path";
+import { fileURLToPath } from "url";
+import { stringify as yamlStringify } from "yaml";
+var plainMode = false;
+function applyColorMode(opts) {
+  if (opts.plain || opts.color === false || process.env["NO_COLOR"] !== void 0) {
+    chalk2.level = 0;
+    plainMode = true;
+  }
+}
+program.name("grimoire").description("Config-driven CLI wizard framework").version("0.3.0").option("--no-color", "Disable colored output").option("--plain", "Plain output mode (no colors, no banner)").hook("preAction", () => {
+  const globalOpts = program.opts();
+  applyColorMode(globalOpts);
+});
+program.command("run").description("Run a wizard from a config file").argument("<config>", "Path to wizard config file (.yaml, .json, .js, .ts)").option("-o, --output <path>", "Write answers to file").option("-f, --format <format>", "Output format: json, env, yaml", "json").option("-q, --quiet", "Suppress header and summary output").option("--dry-run", "Show step plan without running the wizard").option("--mock <json>", "Run wizard with preset answers (JSON string)").option("--json", "Output structured JSON result to stdout").option("--no-cache", "Disable answer caching for this run").option("--renderer <type>", "Renderer to use: inquirer (default) or ink", "inquirer").option("--template <name>", "Load a saved template as defaults").action(async (configPath, opts) => {
+  try {
+    const fullPath = resolve2(configPath);
+    const config = await loadWizardConfig(fullPath);
+    if (opts.dryRun) {
+      printDryRun(config);
+      return;
+    }
+    const mockAnswers = parseMockAnswers(opts.mock);
+    const isJsonOutput = opts.json === true;
+    const renderer = resolveRenderer(opts.renderer);
+    let templateAnswers;
+    if (opts.template) {
+      templateAnswers = loadTemplate(config.meta.name, opts.template);
+      if (!templateAnswers) {
+        console.error(`
+  Template "${opts.template}" not found for "${config.meta.name}".
+`);
+        process.exit(1);
+      }
+    }
+    const answers = await runWizard(config, {
+      renderer,
+      quiet: opts.quiet ?? isJsonOutput,
+      plain: plainMode,
+      mockAnswers,
+      templateAnswers,
+      cache: opts.cache
+    });
+    const rawOutputPath = opts.output ?? config.output?.path;
+    const outputPath = rawOutputPath ? resolve2(resolveTemplate(rawOutputPath, answers)) : void 0;
+    if (isJsonOutput) {
+      const stepsCompleted = Object.keys(answers).length;
+      const result = {
+        ok: true,
+        wizard: config.meta.name,
+        answers,
+        stepsCompleted,
+        format: "json"
+      };
+      const jsonStr = JSON.stringify(result, null, 2);
+      console.log(jsonStr);
+      if (outputPath) {
+        writeFileSync5(outputPath, jsonStr + "\n", "utf-8");
+      }
+      return;
+    }
+    if (outputPath) {
+      const format = opts.format ?? config.output?.format ?? "json";
+      const content = formatOutput(answers, format);
+      writeFileSync5(outputPath, content, "utf-8");
+      if (!opts.quiet) {
+        console.log(`
+  Answers written to: ${outputPath}
+`);
+      }
+    }
+  } catch (error) {
+    if (opts.json) {
+      const result = {
+        ok: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
+      console.log(JSON.stringify(result, null, 2));
+      process.exit(1);
+    }
+    if (error instanceof Error) {
+      console.error(`
+  Error: ${error.message}
+`);
+    }
+    process.exit(1);
+  }
+});
+program.command("validate").description("Validate a wizard config file without running it").argument("<config>", "Path to wizard config file").action(async (configPath) => {
+  try {
+    const fullPath = resolve2(configPath);
+    const config = await loadWizardConfig(fullPath);
+    console.log(`
+  \u2713 Valid wizard config: "${config.meta.name}"`);
+    console.log(`  ${String(config.steps.length)} steps defined
+`);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(`
+  \u2717 Invalid config: ${error.message}
+`);
+    }
+    process.exit(1);
+  }
+});
+program.command("create").description("Interactively scaffold a new wizard config file").argument("[output]", "Output file path", "wizard.yaml").action(async (output) => {
+  try {
+    const resolvedPath = resolve2(output);
+    await scaffoldWizard(resolvedPath);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(`
+  Error: ${error.message}
+`);
+    }
+    process.exit(1);
+  }
+});
+program.command("demo").description("Run a demo wizard showcasing all step types").action(async () => {
+  try {
+    const demoPath = resolve2(
+      fileURLToPath(import.meta.url),
+      "..",
+      "..",
+      "examples",
+      "demo.yaml"
+    );
+    const config = await loadWizardConfig(demoPath);
+    await runWizard(config);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(`
+  Error: ${error.message}
+`);
+    }
+    process.exit(1);
+  }
+});
+program.command("completion").description("Output shell completion script").argument("<shell>", "Shell type: bash, zsh, or fish").action((shell) => {
+  switch (shell) {
+    case "bash":
+      console.log(bashCompletion());
+      break;
+    case "zsh":
+      console.log(zshCompletion());
+      break;
+    case "fish":
+      console.log(fishCompletion());
+      break;
+    default:
+      console.error(`Unknown shell: ${shell}. Supported: bash, zsh, fish`);
+      process.exit(1);
+  }
+});
+var cacheCommand = program.command("cache").description("Manage cached wizard answers");
+cacheCommand.command("clear").description("Delete cached wizard answers").argument("[name]", "Wizard name to clear (clears all if omitted)").action((name) => {
+  clearCache(name);
+  if (name) {
+    console.log(`
+  Cache cleared for "${name}".
+`);
+  } else {
+    console.log("\n  All cached answers cleared.\n");
+  }
+});
+var templateCommand = program.command("template").description("Manage saved wizard answer templates");
+templateCommand.command("list").description("List saved templates for a wizard").argument("<wizard-name>", "Wizard name").action((wizardName) => {
+  const templates = listTemplates(wizardName);
+  if (templates.length === 0) {
+    console.log(`
+  No templates found for "${wizardName}".
+`);
+    return;
+  }
+  console.log(`
+  Templates for "${wizardName}":
+`);
+  for (const t of templates) {
+    console.log(`    - ${t}`);
+  }
+  console.log();
+});
+templateCommand.command("delete").description("Delete a saved template").argument("<wizard-name>", "Wizard name").argument("<template-name>", "Template name").action((wizardName, templateName) => {
+  deleteTemplate(wizardName, templateName);
+  console.log(`
+  Template "${templateName}" deleted from "${wizardName}".
+`);
+});
+program.parse();
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseMockAnswers(mockJson) {
+  if (mockJson === void 0) {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(mockJson);
+    if (!isRecord2(parsed)) {
+      throw new Error("--mock value must be a JSON object");
+    }
+    return parsed;
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw new Error(`--mock value is not valid JSON: ${error.message}`);
+    }
+    throw error;
+  }
+}
+function printDryRun(config) {
+  const theme = resolveTheme(config.theme);
+  const visibleSteps = getVisibleSteps(config, {});
+  console.log();
+  console.log(`  ${theme.bold("Dry Run:")} "${config.meta.name}"`);
+  if (config.meta.description) {
+    console.log(`  ${theme.muted(config.meta.description)}`);
+  }
+  console.log();
+  if (config.checks && config.checks.length > 0) {
+    console.log(`  ${theme.bold("Pre-flight checks:")}`);
+    for (const check of config.checks) {
+      console.log(`    ${theme.muted("\u2022")} ${check.name}: ${theme.muted(check.run)}`);
+    }
+    console.log();
+  }
+  for (let i = 0; i < config.steps.length; i++) {
+    const step = config.steps[i];
+    if (!step) continue;
+    const isVisible = visibleSteps.some((v) => v.id === step.id);
+    const num = String(i + 1).padStart(2, " ");
+    const typeStr = step.type.padEnd(12);
+    const idStr = step.id.padEnd(20);
+    const msg = `"${step.message}"`;
+    const parts = [];
+    if (!isVisible) {
+      parts.push("(hidden)");
+    }
+    if (step.required === false) {
+      parts.push("(optional)");
+    }
+    if (step.type === "multiselect") {
+      if (step.min !== void 0) parts.push(`min:${String(step.min)}`);
+      if (step.max !== void 0) parts.push(`max:${String(step.max)}`);
+    }
+    if (step.when) {
+      parts.push(`[when: ${formatCondition(step.when)}]`);
+    }
+    if (step.type === "select" && step.routes) {
+      const routeParts = Object.entries(step.routes).map(([k, v]) => `${k}\u2192${v}`).join(", ");
+      parts.push(`routes: {${routeParts}}`);
+    }
+    if (step.next) {
+      parts.push(`\u2192 ${step.next}`);
+    }
+    const suffix = parts.length > 0 ? `  ${parts.join("  ")}` : "";
+    console.log(`  Step ${num}  ${typeStr} ${idStr} ${msg}${suffix}`);
+  }
+  console.log();
+  if (config.actions && config.actions.length > 0) {
+    console.log(`  ${theme.bold("Post-wizard actions:")}`);
+    for (const action of config.actions) {
+      const label = action.name ?? action.run;
+      const whenStr = action.when ? `  [when: ${formatCondition(action.when)}]` : "";
+      console.log(`    ${theme.muted("\u2022")} ${label}: ${theme.muted(action.run)}${whenStr}`);
+    }
+    console.log();
+  }
+}
+function formatCondition(condition) {
+  if ("all" in condition) {
+    return `all(${condition.all.map(formatCondition).join(", ")})`;
+  }
+  if ("any" in condition) {
+    return `any(${condition.any.map(formatCondition).join(", ")})`;
+  }
+  if ("not" in condition) {
+    return `not(${formatCondition(condition.not)})`;
+  }
+  if ("equals" in condition) {
+    return `${condition.field} equals ${String(condition.equals)}`;
+  }
+  if ("notEquals" in condition) {
+    return `${condition.field} notEquals ${String(condition.notEquals)}`;
+  }
+  if ("includes" in condition) {
+    return `${condition.field} includes ${String(condition.includes)}`;
+  }
+  if ("notIncludes" in condition) {
+    return `${condition.field} notIncludes ${String(condition.notIncludes)}`;
+  }
+  if ("greaterThan" in condition) {
+    return `${condition.field} > ${String(condition.greaterThan)}`;
+  }
+  if ("lessThan" in condition) {
+    return `${condition.field} < ${String(condition.lessThan)}`;
+  }
+  if ("isEmpty" in condition) {
+    return `${condition.field} isEmpty`;
+  }
+  if ("isNotEmpty" in condition) {
+    return `${condition.field} isNotEmpty`;
+  }
+  return "unknown";
+}
+function resolveRenderer(rendererName) {
+  if (!rendererName || rendererName === "inquirer") {
+    return void 0;
+  }
+  if (rendererName === "ink") {
+    return new InkRenderer();
+  }
+  throw new Error(`Unknown renderer: "${rendererName}". Supported: inquirer, ink`);
+}
+function toEnvKey(key) {
+  return key.replace(/[^a-zA-Z0-9]/g, "_").toUpperCase();
+}
+function formatOutput(answers, format) {
+  switch (format) {
+    case "json":
+      return JSON.stringify(answers, null, 2) + "\n";
+    case "env":
+      return Object.entries(answers).map(([key, value]) => {
+        const strValue = Array.isArray(value) ? value.join(",") : String(value);
+        return `${toEnvKey(key)}=${strValue}`;
+      }).join("\n") + "\n";
+    case "yaml":
+      return yamlStringify(answers);
+    default:
+      return JSON.stringify(answers, null, 2) + "\n";
+  }
+}
+//# sourceMappingURL=cli.js.map